?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "[PATCH] paravirt: Add startup infrastructure for paravirtualization"
[pv_ops_mirror.git] / drivers / net / atl1 / atl1_ethtool.c
blob1f616c5c14739437d0e8efffa856c6df7824825c
1 /*
2 * Copyright(c) 2005 - 2006 Attansic Corporation. All rights reserved.
3 * Copyright(c) 2006 Chris Snook <csnook@redhat.com>
4 * Copyright(c) 2006 Jay Cliburn <jcliburn@gmail.com>
5 *
6 * Derived from Intel e1000 driver
7 * Copyright(c) 1999 - 2005 Intel Corporation. All rights reserved.
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
12 * any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but WITHOUT
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 * more details.
18 *
19 * You should have received a copy of the GNU General Public License along with
20 * this program; if not, write to the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 */
23
24 #include <linux/types.h>
25 #include <linux/pci.h>
26 #include <linux/ethtool.h>
27 #include <linux/netdevice.h>
28 #include <linux/mii.h>
29 #include <asm/uaccess.h>
30
31 #include "atl1.h"
32
33 struct atl1_stats {
34 char stat_string[ETH_GSTRING_LEN];
35 int sizeof_stat;
36 int stat_offset;
37 };
38
39 #define ATL1_STAT(m) sizeof(((struct atl1_adapter *)0)->m), \
40 offsetof(struct atl1_adapter, m)
41
42 static struct atl1_stats atl1_gstrings_stats[] = {
43 {"rx_packets", ATL1_STAT(soft_stats.rx_packets)},
44 {"tx_packets", ATL1_STAT(soft_stats.tx_packets)},
45 {"rx_bytes", ATL1_STAT(soft_stats.rx_bytes)},
46 {"tx_bytes", ATL1_STAT(soft_stats.tx_bytes)},
47 {"rx_errors", ATL1_STAT(soft_stats.rx_errors)},
48 {"tx_errors", ATL1_STAT(soft_stats.tx_errors)},
49 {"rx_dropped", ATL1_STAT(net_stats.rx_dropped)},
50 {"tx_dropped", ATL1_STAT(net_stats.tx_dropped)},
51 {"multicast", ATL1_STAT(soft_stats.multicast)},
52 {"collisions", ATL1_STAT(soft_stats.collisions)},
53 {"rx_length_errors", ATL1_STAT(soft_stats.rx_length_errors)},
54 {"rx_over_errors", ATL1_STAT(soft_stats.rx_missed_errors)},
55 {"rx_crc_errors", ATL1_STAT(soft_stats.rx_crc_errors)},
56 {"rx_frame_errors", ATL1_STAT(soft_stats.rx_frame_errors)},
57 {"rx_fifo_errors", ATL1_STAT(soft_stats.rx_fifo_errors)},
58 {"rx_missed_errors", ATL1_STAT(soft_stats.rx_missed_errors)},
59 {"tx_aborted_errors", ATL1_STAT(soft_stats.tx_aborted_errors)},
60 {"tx_carrier_errors", ATL1_STAT(soft_stats.tx_carrier_errors)},
61 {"tx_fifo_errors", ATL1_STAT(soft_stats.tx_fifo_errors)},
62 {"tx_window_errors", ATL1_STAT(soft_stats.tx_window_errors)},
63 {"tx_abort_exce_coll", ATL1_STAT(soft_stats.excecol)},
64 {"tx_abort_late_coll", ATL1_STAT(soft_stats.latecol)},
65 {"tx_deferred_ok", ATL1_STAT(soft_stats.deffer)},
66 {"tx_single_coll_ok", ATL1_STAT(soft_stats.scc)},
67 {"tx_multi_coll_ok", ATL1_STAT(soft_stats.mcc)},
68 {"tx_underun", ATL1_STAT(soft_stats.tx_underun)},
69 {"tx_trunc", ATL1_STAT(soft_stats.tx_trunc)},
70 {"tx_pause", ATL1_STAT(soft_stats.tx_pause)},
71 {"rx_pause", ATL1_STAT(soft_stats.rx_pause)},
72 {"rx_rrd_ov", ATL1_STAT(soft_stats.rx_rrd_ov)},
73 {"rx_trunc", ATL1_STAT(soft_stats.rx_trunc)}
74 };
75
76 static void atl1_get_ethtool_stats(struct net_device *netdev,
77 struct ethtool_stats *stats, u64 *data)
78 {
79 struct atl1_adapter *adapter = netdev_priv(netdev);
80 int i;
81 char *p;
82
83 for (i = 0; i < ARRAY_SIZE(atl1_gstrings_stats); i++) {
84 p = (char *)adapter+atl1_gstrings_stats[i].stat_offset;
85 data[i] = (atl1_gstrings_stats[i].sizeof_stat ==
86 sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
87 }
88
89 }
90
91 static int atl1_get_stats_count(struct net_device *netdev)
92 {
93 return ARRAY_SIZE(atl1_gstrings_stats);
94 }
95
96 static int atl1_get_settings(struct net_device *netdev,
97 struct ethtool_cmd *ecmd)
98 {
99 struct atl1_adapter *adapter = netdev_priv(netdev);
100 struct atl1_hw *hw = &adapter->hw;
101
102 ecmd->supported = (SUPPORTED_10baseT_Half |
103 SUPPORTED_10baseT_Full |
104 SUPPORTED_100baseT_Half |
105 SUPPORTED_100baseT_Full |
106 SUPPORTED_1000baseT_Full |
107 SUPPORTED_Autoneg | SUPPORTED_TP);
108 ecmd->advertising = ADVERTISED_TP;
109 if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR ||
110 hw->media_type == MEDIA_TYPE_1000M_FULL) {
111 ecmd->advertising |= ADVERTISED_Autoneg;
112 if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR) {
113 ecmd->advertising |= ADVERTISED_Autoneg;
114 ecmd->advertising |=
115 (ADVERTISED_10baseT_Half |
116 ADVERTISED_10baseT_Full |
117 ADVERTISED_100baseT_Half |
118 ADVERTISED_100baseT_Full |
119 ADVERTISED_1000baseT_Full);
120 }
121 else
122 ecmd->advertising |= (ADVERTISED_1000baseT_Full);
123 }
124 ecmd->port = PORT_TP;
125 ecmd->phy_address = 0;
126 ecmd->transceiver = XCVR_INTERNAL;
127
128 if (netif_carrier_ok(adapter->netdev)) {
129 u16 link_speed, link_duplex;
130 atl1_get_speed_and_duplex(hw, &link_speed, &link_duplex);
131 ecmd->speed = link_speed;
132 if (link_duplex == FULL_DUPLEX)
133 ecmd->duplex = DUPLEX_FULL;
134 else
135 ecmd->duplex = DUPLEX_HALF;
136 } else {
137 ecmd->speed = -1;
138 ecmd->duplex = -1;
139 }
140 if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR ||
141 hw->media_type == MEDIA_TYPE_1000M_FULL)
142 ecmd->autoneg = AUTONEG_ENABLE;
143 else
144 ecmd->autoneg = AUTONEG_DISABLE;
145
146 return 0;
147 }
148
149 static int atl1_set_settings(struct net_device *netdev,
150 struct ethtool_cmd *ecmd)
151 {
152 struct atl1_adapter *adapter = netdev_priv(netdev);
153 struct atl1_hw *hw = &adapter->hw;
154 u16 phy_data;
155 int ret_val = 0;
156 u16 old_media_type = hw->media_type;
157
158 if (netif_running(adapter->netdev)) {
159 dev_dbg(&adapter->pdev->dev, "ethtool shutting down adapter\n");
160 atl1_down(adapter);
161 }
162
163 if (ecmd->autoneg == AUTONEG_ENABLE)
164 hw->media_type = MEDIA_TYPE_AUTO_SENSOR;
165 else {
166 if (ecmd->speed == SPEED_1000) {
167 if (ecmd->duplex != DUPLEX_FULL) {
168 dev_warn(&adapter->pdev->dev,
169 "can't force to 1000M half duplex\n");
170 ret_val = -EINVAL;
171 goto exit_sset;
172 }
173 hw->media_type = MEDIA_TYPE_1000M_FULL;
174 } else if (ecmd->speed == SPEED_100) {
175 if (ecmd->duplex == DUPLEX_FULL) {
176 hw->media_type = MEDIA_TYPE_100M_FULL;
177 } else
178 hw->media_type = MEDIA_TYPE_100M_HALF;
179 } else {
180 if (ecmd->duplex == DUPLEX_FULL)
181 hw->media_type = MEDIA_TYPE_10M_FULL;
182 else
183 hw->media_type = MEDIA_TYPE_10M_HALF;
184 }
185 }
186 switch (hw->media_type) {
187 case MEDIA_TYPE_AUTO_SENSOR:
188 ecmd->advertising =
189 ADVERTISED_10baseT_Half |
190 ADVERTISED_10baseT_Full |
191 ADVERTISED_100baseT_Half |
192 ADVERTISED_100baseT_Full |
193 ADVERTISED_1000baseT_Full |
194 ADVERTISED_Autoneg | ADVERTISED_TP;
195 break;
196 case MEDIA_TYPE_1000M_FULL:
197 ecmd->advertising =
198 ADVERTISED_1000baseT_Full |
199 ADVERTISED_Autoneg | ADVERTISED_TP;
200 break;
201 default:
202 ecmd->advertising = 0;
203 break;
204 }
205 if (atl1_phy_setup_autoneg_adv(hw)) {
206 ret_val = -EINVAL;
207 dev_warn(&adapter->pdev->dev,
208 "invalid ethtool speed/duplex setting\n");
209 goto exit_sset;
210 }
211 if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR ||
212 hw->media_type == MEDIA_TYPE_1000M_FULL)
213 phy_data = MII_CR_RESET | MII_CR_AUTO_NEG_EN;
214 else {
215 switch (hw->media_type) {
216 case MEDIA_TYPE_100M_FULL:
217 phy_data =
218 MII_CR_FULL_DUPLEX | MII_CR_SPEED_100 |
219 MII_CR_RESET;
220 break;
221 case MEDIA_TYPE_100M_HALF:
222 phy_data = MII_CR_SPEED_100 | MII_CR_RESET;
223 break;
224 case MEDIA_TYPE_10M_FULL:
225 phy_data =
226 MII_CR_FULL_DUPLEX | MII_CR_SPEED_10 | MII_CR_RESET;
227 break;
228 default: /* MEDIA_TYPE_10M_HALF: */
229 phy_data = MII_CR_SPEED_10 | MII_CR_RESET;
230 break;
231 }
232 }
233 atl1_write_phy_reg(hw, MII_BMCR, phy_data);
234 exit_sset:
235 if (ret_val)
236 hw->media_type = old_media_type;
237
238 if (netif_running(adapter->netdev)) {
239 dev_dbg(&adapter->pdev->dev, "ethtool starting adapter\n");
240 atl1_up(adapter);
241 } else if (!ret_val) {
242 dev_dbg(&adapter->pdev->dev, "ethtool resetting adapter\n");
243 atl1_reset(adapter);
244 }
245 return ret_val;
246 }
247
248 static void atl1_get_drvinfo(struct net_device *netdev,
249 struct ethtool_drvinfo *drvinfo)
250 {
251 struct atl1_adapter *adapter = netdev_priv(netdev);
252
253 strncpy(drvinfo->driver, atl1_driver_name, sizeof(drvinfo->driver));
254 strncpy(drvinfo->version, atl1_driver_version,
255 sizeof(drvinfo->version));
256 strncpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
257 strncpy(drvinfo->bus_info, pci_name(adapter->pdev),
258 sizeof(drvinfo->bus_info));
259 drvinfo->eedump_len = ATL1_EEDUMP_LEN;
260 }
261
262 static void atl1_get_wol(struct net_device *netdev,
263 struct ethtool_wolinfo *wol)
264 {
265 struct atl1_adapter *adapter = netdev_priv(netdev);
266
267 wol->supported = WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | WAKE_MAGIC;
268 wol->wolopts = 0;
269 if (adapter->wol & ATL1_WUFC_EX)
270 wol->wolopts |= WAKE_UCAST;
271 if (adapter->wol & ATL1_WUFC_MC)
272 wol->wolopts |= WAKE_MCAST;
273 if (adapter->wol & ATL1_WUFC_BC)
274 wol->wolopts |= WAKE_BCAST;
275 if (adapter->wol & ATL1_WUFC_MAG)
276 wol->wolopts |= WAKE_MAGIC;
277 return;
278 }
279
280 static int atl1_set_wol(struct net_device *netdev,
281 struct ethtool_wolinfo *wol)
282 {
283 struct atl1_adapter *adapter = netdev_priv(netdev);
284
285 if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
286 return -EOPNOTSUPP;
287 adapter->wol = 0;
288 if (wol->wolopts & WAKE_UCAST)
289 adapter->wol |= ATL1_WUFC_EX;
290 if (wol->wolopts & WAKE_MCAST)
291 adapter->wol |= ATL1_WUFC_MC;
292 if (wol->wolopts & WAKE_BCAST)
293 adapter->wol |= ATL1_WUFC_BC;
294 if (wol->wolopts & WAKE_MAGIC)
295 adapter->wol |= ATL1_WUFC_MAG;
296 return 0;
297 }
298
299 static void atl1_get_ringparam(struct net_device *netdev,
300 struct ethtool_ringparam *ring)
301 {
302 struct atl1_adapter *adapter = netdev_priv(netdev);
303 struct atl1_tpd_ring *txdr = &adapter->tpd_ring;
304 struct atl1_rfd_ring *rxdr = &adapter->rfd_ring;
305
306 ring->rx_max_pending = ATL1_MAX_RFD;
307 ring->tx_max_pending = ATL1_MAX_TPD;
308 ring->rx_mini_max_pending = 0;
309 ring->rx_jumbo_max_pending = 0;
310 ring->rx_pending = rxdr->count;
311 ring->tx_pending = txdr->count;
312 ring->rx_mini_pending = 0;
313 ring->rx_jumbo_pending = 0;
314 }
315
316 static int atl1_set_ringparam(struct net_device *netdev,
317 struct ethtool_ringparam *ring)
318 {
319 struct atl1_adapter *adapter = netdev_priv(netdev);
320 struct atl1_tpd_ring *tpdr = &adapter->tpd_ring;
321 struct atl1_rrd_ring *rrdr = &adapter->rrd_ring;
322 struct atl1_rfd_ring *rfdr = &adapter->rfd_ring;
323
324 struct atl1_tpd_ring tpd_old, tpd_new;
325 struct atl1_rfd_ring rfd_old, rfd_new;
326 struct atl1_rrd_ring rrd_old, rrd_new;
327 struct atl1_ring_header rhdr_old, rhdr_new;
328 int err;
329
330 tpd_old = adapter->tpd_ring;
331 rfd_old = adapter->rfd_ring;
332 rrd_old = adapter->rrd_ring;
333 rhdr_old = adapter->ring_header;
334
335 if (netif_running(adapter->netdev))
336 atl1_down(adapter);
337
338 rfdr->count = (u16) max(ring->rx_pending, (u32) ATL1_MIN_RFD);
339 rfdr->count = rfdr->count > ATL1_MAX_RFD ? ATL1_MAX_RFD :
340 rfdr->count;
341 rfdr->count = (rfdr->count + 3) & ~3;
342 rrdr->count = rfdr->count;
343
344 tpdr->count = (u16) max(ring->tx_pending, (u32) ATL1_MIN_TPD);
345 tpdr->count = tpdr->count > ATL1_MAX_TPD ? ATL1_MAX_TPD :
346 tpdr->count;
347 tpdr->count = (tpdr->count + 3) & ~3;
348
349 if (netif_running(adapter->netdev)) {
350 /* try to get new resources before deleting old */
351 err = atl1_setup_ring_resources(adapter);
352 if (err)
353 goto err_setup_ring;
354
355 /*
356 * save the new, restore the old in order to free it,
357 * then restore the new back again
358 */
359
360 rfd_new = adapter->rfd_ring;
361 rrd_new = adapter->rrd_ring;
362 tpd_new = adapter->tpd_ring;
363 rhdr_new = adapter->ring_header;
364 adapter->rfd_ring = rfd_old;
365 adapter->rrd_ring = rrd_old;
366 adapter->tpd_ring = tpd_old;
367 adapter->ring_header = rhdr_old;
368 atl1_free_ring_resources(adapter);
369 adapter->rfd_ring = rfd_new;
370 adapter->rrd_ring = rrd_new;
371 adapter->tpd_ring = tpd_new;
372 adapter->ring_header = rhdr_new;
373
374 err = atl1_up(adapter);
375 if (err)
376 return err;
377 }
378 return 0;
379
380 err_setup_ring:
381 adapter->rfd_ring = rfd_old;
382 adapter->rrd_ring = rrd_old;
383 adapter->tpd_ring = tpd_old;
384 adapter->ring_header = rhdr_old;
385 atl1_up(adapter);
386 return err;
387 }
388
389 static void atl1_get_pauseparam(struct net_device *netdev,
390 struct ethtool_pauseparam *epause)
391 {
392 struct atl1_adapter *adapter = netdev_priv(netdev);
393 struct atl1_hw *hw = &adapter->hw;
394
395 if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR ||
396 hw->media_type == MEDIA_TYPE_1000M_FULL) {
397 epause->autoneg = AUTONEG_ENABLE;
398 } else {
399 epause->autoneg = AUTONEG_DISABLE;
400 }
401 epause->rx_pause = 1;
402 epause->tx_pause = 1;
403 }
404
405 static int atl1_set_pauseparam(struct net_device *netdev,
406 struct ethtool_pauseparam *epause)
407 {
408 struct atl1_adapter *adapter = netdev_priv(netdev);
409 struct atl1_hw *hw = &adapter->hw;
410
411 if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR ||
412 hw->media_type == MEDIA_TYPE_1000M_FULL) {
413 epause->autoneg = AUTONEG_ENABLE;
414 } else {
415 epause->autoneg = AUTONEG_DISABLE;
416 }
417
418 epause->rx_pause = 1;
419 epause->tx_pause = 1;
420
421 return 0;
422 }
423
424 static u32 atl1_get_rx_csum(struct net_device *netdev)
425 {
426 return 1;
427 }
428
429 static void atl1_get_strings(struct net_device *netdev, u32 stringset,
430 u8 *data)
431 {
432 u8 *p = data;
433 int i;
434
435 switch (stringset) {
436 case ETH_SS_STATS:
437 for (i = 0; i < ARRAY_SIZE(atl1_gstrings_stats); i++) {
438 memcpy(p, atl1_gstrings_stats[i].stat_string,
439 ETH_GSTRING_LEN);
440 p += ETH_GSTRING_LEN;
441 }
442 break;
443 }
444 }
445
446 static int atl1_nway_reset(struct net_device *netdev)
447 {
448 struct atl1_adapter *adapter = netdev_priv(netdev);
449 struct atl1_hw *hw = &adapter->hw;
450
451 if (netif_running(netdev)) {
452 u16 phy_data;
453 atl1_down(adapter);
454
455 if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR ||
456 hw->media_type == MEDIA_TYPE_1000M_FULL) {
457 phy_data = MII_CR_RESET | MII_CR_AUTO_NEG_EN;
458 } else {
459 switch (hw->media_type) {
460 case MEDIA_TYPE_100M_FULL:
461 phy_data = MII_CR_FULL_DUPLEX |
462 MII_CR_SPEED_100 | MII_CR_RESET;
463 break;
464 case MEDIA_TYPE_100M_HALF:
465 phy_data = MII_CR_SPEED_100 | MII_CR_RESET;
466 break;
467 case MEDIA_TYPE_10M_FULL:
468 phy_data = MII_CR_FULL_DUPLEX |
469 MII_CR_SPEED_10 | MII_CR_RESET;
470 break;
471 default: /* MEDIA_TYPE_10M_HALF */
472 phy_data = MII_CR_SPEED_10 | MII_CR_RESET;
473 }
474 }
475 atl1_write_phy_reg(hw, MII_BMCR, phy_data);
476 atl1_up(adapter);
477 }
478 return 0;
479 }
480
481 const struct ethtool_ops atl1_ethtool_ops = {
482 .get_settings = atl1_get_settings,
483 .set_settings = atl1_set_settings,
484 .get_drvinfo = atl1_get_drvinfo,
485 .get_wol = atl1_get_wol,
486 .set_wol = atl1_set_wol,
487 .get_ringparam = atl1_get_ringparam,
488 .set_ringparam = atl1_set_ringparam,
489 .get_pauseparam = atl1_get_pauseparam,
490 .set_pauseparam = atl1_set_pauseparam,
491 .get_rx_csum = atl1_get_rx_csum,
492 .get_tx_csum = ethtool_op_get_tx_csum,
493 .set_tx_csum = ethtool_op_set_tx_hw_csum,
494 .get_link = ethtool_op_get_link,
495 .get_sg = ethtool_op_get_sg,
496 .set_sg = ethtool_op_set_sg,
497 .get_strings = atl1_get_strings,
498 .nway_reset = atl1_nway_reset,
499 .get_ethtool_stats = atl1_get_ethtool_stats,
500 .get_stats_count = atl1_get_stats_count,
501 .get_tso = ethtool_op_get_tso,
502 .set_tso = ethtool_op_set_tso,
503 };
Mirror for ia64_pv_ops.git