1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright(c) 1999 - 2006 Intel Corporation. */ |
3 | |
4 | /* ethtool support for e1000 */ |
5 | |
6 | #include "e1000.h" |
7 | #include <linux/jiffies.h> |
8 | #include <linux/uaccess.h> |
9 | |
10 | enum {NETDEV_STATS, E1000_STATS}; |
11 | |
12 | struct e1000_stats { |
13 | char stat_string[ETH_GSTRING_LEN]; |
14 | int type; |
15 | int sizeof_stat; |
16 | int stat_offset; |
17 | }; |
18 | |
19 | #define E1000_STAT(m) E1000_STATS, \ |
20 | sizeof(((struct e1000_adapter *)0)->m), \ |
21 | offsetof(struct e1000_adapter, m) |
22 | #define E1000_NETDEV_STAT(m) NETDEV_STATS, \ |
23 | sizeof(((struct net_device *)0)->m), \ |
24 | offsetof(struct net_device, m) |
25 | |
26 | static const struct e1000_stats e1000_gstrings_stats[] = { |
27 | { "rx_packets" , E1000_STAT(stats.gprc) }, |
28 | { "tx_packets" , E1000_STAT(stats.gptc) }, |
29 | { "rx_bytes" , E1000_STAT(stats.gorcl) }, |
30 | { "tx_bytes" , E1000_STAT(stats.gotcl) }, |
31 | { "rx_broadcast" , E1000_STAT(stats.bprc) }, |
32 | { "tx_broadcast" , E1000_STAT(stats.bptc) }, |
33 | { "rx_multicast" , E1000_STAT(stats.mprc) }, |
34 | { "tx_multicast" , E1000_STAT(stats.mptc) }, |
35 | { "rx_errors" , E1000_STAT(stats.rxerrc) }, |
36 | { "tx_errors" , E1000_STAT(stats.txerrc) }, |
37 | { "tx_dropped" , E1000_NETDEV_STAT(stats.tx_dropped) }, |
38 | { "multicast" , E1000_STAT(stats.mprc) }, |
39 | { "collisions" , E1000_STAT(stats.colc) }, |
40 | { "rx_length_errors" , E1000_STAT(stats.rlerrc) }, |
41 | { "rx_over_errors" , E1000_NETDEV_STAT(stats.rx_over_errors) }, |
42 | { "rx_crc_errors" , E1000_STAT(stats.crcerrs) }, |
43 | { "rx_frame_errors" , E1000_NETDEV_STAT(stats.rx_frame_errors) }, |
44 | { "rx_no_buffer_count" , E1000_STAT(stats.rnbc) }, |
45 | { "rx_missed_errors" , E1000_STAT(stats.mpc) }, |
46 | { "tx_aborted_errors" , E1000_STAT(stats.ecol) }, |
47 | { "tx_carrier_errors" , E1000_STAT(stats.tncrs) }, |
48 | { "tx_fifo_errors" , E1000_NETDEV_STAT(stats.tx_fifo_errors) }, |
49 | { "tx_heartbeat_errors" , E1000_NETDEV_STAT(stats.tx_heartbeat_errors) }, |
50 | { "tx_window_errors" , E1000_STAT(stats.latecol) }, |
51 | { "tx_abort_late_coll" , E1000_STAT(stats.latecol) }, |
52 | { "tx_deferred_ok" , E1000_STAT(stats.dc) }, |
53 | { "tx_single_coll_ok" , E1000_STAT(stats.scc) }, |
54 | { "tx_multi_coll_ok" , E1000_STAT(stats.mcc) }, |
55 | { "tx_timeout_count" , E1000_STAT(tx_timeout_count) }, |
56 | { "tx_restart_queue" , E1000_STAT(restart_queue) }, |
57 | { "rx_long_length_errors" , E1000_STAT(stats.roc) }, |
58 | { "rx_short_length_errors" , E1000_STAT(stats.ruc) }, |
59 | { "rx_align_errors" , E1000_STAT(stats.algnerrc) }, |
60 | { "tx_tcp_seg_good" , E1000_STAT(stats.tsctc) }, |
61 | { "tx_tcp_seg_failed" , E1000_STAT(stats.tsctfc) }, |
62 | { "rx_flow_control_xon" , E1000_STAT(stats.xonrxc) }, |
63 | { "rx_flow_control_xoff" , E1000_STAT(stats.xoffrxc) }, |
64 | { "tx_flow_control_xon" , E1000_STAT(stats.xontxc) }, |
65 | { "tx_flow_control_xoff" , E1000_STAT(stats.xofftxc) }, |
66 | { "rx_long_byte_count" , E1000_STAT(stats.gorcl) }, |
67 | { "rx_csum_offload_good" , E1000_STAT(hw_csum_good) }, |
68 | { "rx_csum_offload_errors" , E1000_STAT(hw_csum_err) }, |
69 | { "alloc_rx_buff_failed" , E1000_STAT(alloc_rx_buff_failed) }, |
70 | { "tx_smbus" , E1000_STAT(stats.mgptc) }, |
71 | { "rx_smbus" , E1000_STAT(stats.mgprc) }, |
72 | { "dropped_smbus" , E1000_STAT(stats.mgpdc) }, |
73 | }; |
74 | |
75 | #define E1000_QUEUE_STATS_LEN 0 |
76 | #define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats) |
77 | #define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_STATS_LEN) |
78 | static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = { |
79 | "Register test (offline)" , "Eeprom test (offline)" , |
80 | "Interrupt test (offline)" , "Loopback test (offline)" , |
81 | "Link test (on/offline)" |
82 | }; |
83 | |
84 | #define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test) |
85 | |
86 | static int e1000_get_link_ksettings(struct net_device *netdev, |
87 | struct ethtool_link_ksettings *cmd) |
88 | { |
89 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
90 | struct e1000_hw *hw = &adapter->hw; |
91 | u32 supported, advertising; |
92 | |
93 | if (hw->media_type == e1000_media_type_copper) { |
94 | supported = (SUPPORTED_10baseT_Half | |
95 | SUPPORTED_10baseT_Full | |
96 | SUPPORTED_100baseT_Half | |
97 | SUPPORTED_100baseT_Full | |
98 | SUPPORTED_1000baseT_Full| |
99 | SUPPORTED_Autoneg | |
100 | SUPPORTED_TP); |
101 | advertising = ADVERTISED_TP; |
102 | |
103 | if (hw->autoneg == 1) { |
104 | advertising |= ADVERTISED_Autoneg; |
105 | /* the e1000 autoneg seems to match ethtool nicely */ |
106 | advertising |= hw->autoneg_advertised; |
107 | } |
108 | |
109 | cmd->base.port = PORT_TP; |
110 | cmd->base.phy_address = hw->phy_addr; |
111 | } else { |
112 | supported = (SUPPORTED_1000baseT_Full | |
113 | SUPPORTED_FIBRE | |
114 | SUPPORTED_Autoneg); |
115 | |
116 | advertising = (ADVERTISED_1000baseT_Full | |
117 | ADVERTISED_FIBRE | |
118 | ADVERTISED_Autoneg); |
119 | |
120 | cmd->base.port = PORT_FIBRE; |
121 | } |
122 | |
123 | if (er32(STATUS) & E1000_STATUS_LU) { |
124 | e1000_get_speed_and_duplex(hw, speed: &adapter->link_speed, |
125 | duplex: &adapter->link_duplex); |
126 | cmd->base.speed = adapter->link_speed; |
127 | |
128 | /* unfortunately FULL_DUPLEX != DUPLEX_FULL |
129 | * and HALF_DUPLEX != DUPLEX_HALF |
130 | */ |
131 | if (adapter->link_duplex == FULL_DUPLEX) |
132 | cmd->base.duplex = DUPLEX_FULL; |
133 | else |
134 | cmd->base.duplex = DUPLEX_HALF; |
135 | } else { |
136 | cmd->base.speed = SPEED_UNKNOWN; |
137 | cmd->base.duplex = DUPLEX_UNKNOWN; |
138 | } |
139 | |
140 | cmd->base.autoneg = ((hw->media_type == e1000_media_type_fiber) || |
141 | hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE; |
142 | |
143 | /* MDI-X => 1; MDI => 0 */ |
144 | if ((hw->media_type == e1000_media_type_copper) && |
145 | netif_carrier_ok(dev: netdev)) |
146 | cmd->base.eth_tp_mdix = (!!adapter->phy_info.mdix_mode ? |
147 | ETH_TP_MDI_X : ETH_TP_MDI); |
148 | else |
149 | cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; |
150 | |
151 | if (hw->mdix == AUTO_ALL_MODES) |
152 | cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO; |
153 | else |
154 | cmd->base.eth_tp_mdix_ctrl = hw->mdix; |
155 | |
156 | ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.supported, |
157 | legacy_u32: supported); |
158 | ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.advertising, |
159 | legacy_u32: advertising); |
160 | |
161 | return 0; |
162 | } |
163 | |
164 | static int e1000_set_link_ksettings(struct net_device *netdev, |
165 | const struct ethtool_link_ksettings *cmd) |
166 | { |
167 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
168 | struct e1000_hw *hw = &adapter->hw; |
169 | u32 advertising; |
170 | |
171 | ethtool_convert_link_mode_to_legacy_u32(legacy_u32: &advertising, |
172 | src: cmd->link_modes.advertising); |
173 | |
174 | /* MDI setting is only allowed when autoneg enabled because |
175 | * some hardware doesn't allow MDI setting when speed or |
176 | * duplex is forced. |
177 | */ |
178 | if (cmd->base.eth_tp_mdix_ctrl) { |
179 | if (hw->media_type != e1000_media_type_copper) |
180 | return -EOPNOTSUPP; |
181 | |
182 | if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) && |
183 | (cmd->base.autoneg != AUTONEG_ENABLE)) { |
184 | e_err(drv, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n" ); |
185 | return -EINVAL; |
186 | } |
187 | } |
188 | |
189 | while (test_and_set_bit(nr: __E1000_RESETTING, addr: &adapter->flags)) |
190 | msleep(msecs: 1); |
191 | |
192 | if (cmd->base.autoneg == AUTONEG_ENABLE) { |
193 | hw->autoneg = 1; |
194 | if (hw->media_type == e1000_media_type_fiber) |
195 | hw->autoneg_advertised = ADVERTISED_1000baseT_Full | |
196 | ADVERTISED_FIBRE | |
197 | ADVERTISED_Autoneg; |
198 | else |
199 | hw->autoneg_advertised = advertising | |
200 | ADVERTISED_TP | |
201 | ADVERTISED_Autoneg; |
202 | } else { |
203 | u32 speed = cmd->base.speed; |
204 | /* calling this overrides forced MDI setting */ |
205 | if (e1000_set_spd_dplx(adapter, spd: speed, dplx: cmd->base.duplex)) { |
206 | clear_bit(nr: __E1000_RESETTING, addr: &adapter->flags); |
207 | return -EINVAL; |
208 | } |
209 | } |
210 | |
211 | /* MDI-X => 2; MDI => 1; Auto => 3 */ |
212 | if (cmd->base.eth_tp_mdix_ctrl) { |
213 | if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) |
214 | hw->mdix = AUTO_ALL_MODES; |
215 | else |
216 | hw->mdix = cmd->base.eth_tp_mdix_ctrl; |
217 | } |
218 | |
219 | /* reset the link */ |
220 | |
221 | if (netif_running(dev: adapter->netdev)) { |
222 | e1000_down(adapter); |
223 | e1000_up(adapter); |
224 | } else { |
225 | e1000_reset(adapter); |
226 | } |
227 | clear_bit(nr: __E1000_RESETTING, addr: &adapter->flags); |
228 | return 0; |
229 | } |
230 | |
231 | static u32 e1000_get_link(struct net_device *netdev) |
232 | { |
233 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
234 | |
235 | /* If the link is not reported up to netdev, interrupts are disabled, |
236 | * and so the physical link state may have changed since we last |
237 | * looked. Set get_link_status to make sure that the true link |
238 | * state is interrogated, rather than pulling a cached and possibly |
239 | * stale link state from the driver. |
240 | */ |
241 | if (!netif_carrier_ok(dev: netdev)) |
242 | adapter->hw.get_link_status = 1; |
243 | |
244 | return e1000_has_link(adapter); |
245 | } |
246 | |
247 | static void e1000_get_pauseparam(struct net_device *netdev, |
248 | struct ethtool_pauseparam *pause) |
249 | { |
250 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
251 | struct e1000_hw *hw = &adapter->hw; |
252 | |
253 | pause->autoneg = |
254 | (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE); |
255 | |
256 | if (hw->fc == E1000_FC_RX_PAUSE) { |
257 | pause->rx_pause = 1; |
258 | } else if (hw->fc == E1000_FC_TX_PAUSE) { |
259 | pause->tx_pause = 1; |
260 | } else if (hw->fc == E1000_FC_FULL) { |
261 | pause->rx_pause = 1; |
262 | pause->tx_pause = 1; |
263 | } |
264 | } |
265 | |
266 | static int e1000_set_pauseparam(struct net_device *netdev, |
267 | struct ethtool_pauseparam *pause) |
268 | { |
269 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
270 | struct e1000_hw *hw = &adapter->hw; |
271 | int retval = 0; |
272 | |
273 | adapter->fc_autoneg = pause->autoneg; |
274 | |
275 | while (test_and_set_bit(nr: __E1000_RESETTING, addr: &adapter->flags)) |
276 | msleep(msecs: 1); |
277 | |
278 | if (pause->rx_pause && pause->tx_pause) |
279 | hw->fc = E1000_FC_FULL; |
280 | else if (pause->rx_pause && !pause->tx_pause) |
281 | hw->fc = E1000_FC_RX_PAUSE; |
282 | else if (!pause->rx_pause && pause->tx_pause) |
283 | hw->fc = E1000_FC_TX_PAUSE; |
284 | else if (!pause->rx_pause && !pause->tx_pause) |
285 | hw->fc = E1000_FC_NONE; |
286 | |
287 | hw->original_fc = hw->fc; |
288 | |
289 | if (adapter->fc_autoneg == AUTONEG_ENABLE) { |
290 | if (netif_running(dev: adapter->netdev)) { |
291 | e1000_down(adapter); |
292 | e1000_up(adapter); |
293 | } else { |
294 | e1000_reset(adapter); |
295 | } |
296 | } else |
297 | retval = ((hw->media_type == e1000_media_type_fiber) ? |
298 | e1000_setup_link(hw) : e1000_force_mac_fc(hw)); |
299 | |
300 | clear_bit(nr: __E1000_RESETTING, addr: &adapter->flags); |
301 | return retval; |
302 | } |
303 | |
304 | static u32 e1000_get_msglevel(struct net_device *netdev) |
305 | { |
306 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
307 | |
308 | return adapter->msg_enable; |
309 | } |
310 | |
311 | static void e1000_set_msglevel(struct net_device *netdev, u32 data) |
312 | { |
313 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
314 | |
315 | adapter->msg_enable = data; |
316 | } |
317 | |
318 | static int e1000_get_regs_len(struct net_device *netdev) |
319 | { |
320 | #define E1000_REGS_LEN 32 |
321 | return E1000_REGS_LEN * sizeof(u32); |
322 | } |
323 | |
324 | static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs, |
325 | void *p) |
326 | { |
327 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
328 | struct e1000_hw *hw = &adapter->hw; |
329 | u32 *regs_buff = p; |
330 | u16 phy_data; |
331 | |
332 | memset(p, 0, E1000_REGS_LEN * sizeof(u32)); |
333 | |
334 | regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id; |
335 | |
336 | regs_buff[0] = er32(CTRL); |
337 | regs_buff[1] = er32(STATUS); |
338 | |
339 | regs_buff[2] = er32(RCTL); |
340 | regs_buff[3] = er32(RDLEN); |
341 | regs_buff[4] = er32(RDH); |
342 | regs_buff[5] = er32(RDT); |
343 | regs_buff[6] = er32(RDTR); |
344 | |
345 | regs_buff[7] = er32(TCTL); |
346 | regs_buff[8] = er32(TDLEN); |
347 | regs_buff[9] = er32(TDH); |
348 | regs_buff[10] = er32(TDT); |
349 | regs_buff[11] = er32(TIDV); |
350 | |
351 | regs_buff[12] = hw->phy_type; /* PHY type (IGP=1, M88=0) */ |
352 | if (hw->phy_type == e1000_phy_igp) { |
353 | e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, |
354 | IGP01E1000_PHY_AGC_A); |
355 | e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A & |
356 | IGP01E1000_PHY_PAGE_SELECT, phy_data: &phy_data); |
357 | regs_buff[13] = (u32)phy_data; /* cable length */ |
358 | e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, |
359 | IGP01E1000_PHY_AGC_B); |
360 | e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B & |
361 | IGP01E1000_PHY_PAGE_SELECT, phy_data: &phy_data); |
362 | regs_buff[14] = (u32)phy_data; /* cable length */ |
363 | e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, |
364 | IGP01E1000_PHY_AGC_C); |
365 | e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C & |
366 | IGP01E1000_PHY_PAGE_SELECT, phy_data: &phy_data); |
367 | regs_buff[15] = (u32)phy_data; /* cable length */ |
368 | e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, |
369 | IGP01E1000_PHY_AGC_D); |
370 | e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D & |
371 | IGP01E1000_PHY_PAGE_SELECT, phy_data: &phy_data); |
372 | regs_buff[16] = (u32)phy_data; /* cable length */ |
373 | regs_buff[17] = 0; /* extended 10bt distance (not needed) */ |
374 | e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, data: 0x0); |
375 | e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS & |
376 | IGP01E1000_PHY_PAGE_SELECT, phy_data: &phy_data); |
377 | regs_buff[18] = (u32)phy_data; /* cable polarity */ |
378 | e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, |
379 | IGP01E1000_PHY_PCS_INIT_REG); |
380 | e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG & |
381 | IGP01E1000_PHY_PAGE_SELECT, phy_data: &phy_data); |
382 | regs_buff[19] = (u32)phy_data; /* cable polarity */ |
383 | regs_buff[20] = 0; /* polarity correction enabled (always) */ |
384 | regs_buff[22] = 0; /* phy receive errors (unavailable) */ |
385 | regs_buff[23] = regs_buff[18]; /* mdix mode */ |
386 | e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, data: 0x0); |
387 | } else { |
388 | e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, phy_data: &phy_data); |
389 | regs_buff[13] = (u32)phy_data; /* cable length */ |
390 | regs_buff[14] = 0; /* Dummy (to align w/ IGP phy reg dump) */ |
391 | regs_buff[15] = 0; /* Dummy (to align w/ IGP phy reg dump) */ |
392 | regs_buff[16] = 0; /* Dummy (to align w/ IGP phy reg dump) */ |
393 | e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data: &phy_data); |
394 | regs_buff[17] = (u32)phy_data; /* extended 10bt distance */ |
395 | regs_buff[18] = regs_buff[13]; /* cable polarity */ |
396 | regs_buff[19] = 0; /* Dummy (to align w/ IGP phy reg dump) */ |
397 | regs_buff[20] = regs_buff[17]; /* polarity correction */ |
398 | /* phy receive errors */ |
399 | regs_buff[22] = adapter->phy_stats.receive_errors; |
400 | regs_buff[23] = regs_buff[13]; /* mdix mode */ |
401 | } |
402 | regs_buff[21] = adapter->phy_stats.idle_errors; /* phy idle errors */ |
403 | e1000_read_phy_reg(hw, PHY_1000T_STATUS, phy_data: &phy_data); |
404 | regs_buff[24] = (u32)phy_data; /* phy local receiver status */ |
405 | regs_buff[25] = regs_buff[24]; /* phy remote receiver status */ |
406 | if (hw->mac_type >= e1000_82540 && |
407 | hw->media_type == e1000_media_type_copper) { |
408 | regs_buff[26] = er32(MANC); |
409 | } |
410 | } |
411 | |
412 | static int e1000_get_eeprom_len(struct net_device *netdev) |
413 | { |
414 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
415 | struct e1000_hw *hw = &adapter->hw; |
416 | |
417 | return hw->eeprom.word_size * 2; |
418 | } |
419 | |
420 | static int e1000_get_eeprom(struct net_device *netdev, |
421 | struct ethtool_eeprom *eeprom, u8 *bytes) |
422 | { |
423 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
424 | struct e1000_hw *hw = &adapter->hw; |
425 | u16 *eeprom_buff; |
426 | int first_word, last_word; |
427 | int ret_val = 0; |
428 | u16 i; |
429 | |
430 | if (eeprom->len == 0) |
431 | return -EINVAL; |
432 | |
433 | eeprom->magic = hw->vendor_id | (hw->device_id << 16); |
434 | |
435 | first_word = eeprom->offset >> 1; |
436 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
437 | |
438 | eeprom_buff = kmalloc_array(n: last_word - first_word + 1, size: sizeof(u16), |
439 | GFP_KERNEL); |
440 | if (!eeprom_buff) |
441 | return -ENOMEM; |
442 | |
443 | if (hw->eeprom.type == e1000_eeprom_spi) |
444 | ret_val = e1000_read_eeprom(hw, reg: first_word, |
445 | words: last_word - first_word + 1, |
446 | data: eeprom_buff); |
447 | else { |
448 | for (i = 0; i < last_word - first_word + 1; i++) { |
449 | ret_val = e1000_read_eeprom(hw, reg: first_word + i, words: 1, |
450 | data: &eeprom_buff[i]); |
451 | if (ret_val) |
452 | break; |
453 | } |
454 | } |
455 | |
456 | /* Device's eeprom is always little-endian, word addressable */ |
457 | for (i = 0; i < last_word - first_word + 1; i++) |
458 | le16_to_cpus(&eeprom_buff[i]); |
459 | |
460 | memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), |
461 | eeprom->len); |
462 | kfree(objp: eeprom_buff); |
463 | |
464 | return ret_val; |
465 | } |
466 | |
467 | static int e1000_set_eeprom(struct net_device *netdev, |
468 | struct ethtool_eeprom *eeprom, u8 *bytes) |
469 | { |
470 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
471 | struct e1000_hw *hw = &adapter->hw; |
472 | u16 *eeprom_buff; |
473 | void *ptr; |
474 | int max_len, first_word, last_word, ret_val = 0; |
475 | u16 i; |
476 | |
477 | if (eeprom->len == 0) |
478 | return -EOPNOTSUPP; |
479 | |
480 | if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16))) |
481 | return -EFAULT; |
482 | |
483 | max_len = hw->eeprom.word_size * 2; |
484 | |
485 | first_word = eeprom->offset >> 1; |
486 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
487 | eeprom_buff = kmalloc(size: max_len, GFP_KERNEL); |
488 | if (!eeprom_buff) |
489 | return -ENOMEM; |
490 | |
491 | ptr = (void *)eeprom_buff; |
492 | |
493 | if (eeprom->offset & 1) { |
494 | /* need read/modify/write of first changed EEPROM word |
495 | * only the second byte of the word is being modified |
496 | */ |
497 | ret_val = e1000_read_eeprom(hw, reg: first_word, words: 1, |
498 | data: &eeprom_buff[0]); |
499 | ptr++; |
500 | } |
501 | if (((eeprom->offset + eeprom->len) & 1) && (ret_val == 0)) { |
502 | /* need read/modify/write of last changed EEPROM word |
503 | * only the first byte of the word is being modified |
504 | */ |
505 | ret_val = e1000_read_eeprom(hw, reg: last_word, words: 1, |
506 | data: &eeprom_buff[last_word - first_word]); |
507 | } |
508 | |
509 | /* Device's eeprom is always little-endian, word addressable */ |
510 | for (i = 0; i < last_word - first_word + 1; i++) |
511 | le16_to_cpus(&eeprom_buff[i]); |
512 | |
513 | memcpy(ptr, bytes, eeprom->len); |
514 | |
515 | for (i = 0; i < last_word - first_word + 1; i++) |
516 | cpu_to_le16s(&eeprom_buff[i]); |
517 | |
518 | ret_val = e1000_write_eeprom(hw, reg: first_word, |
519 | words: last_word - first_word + 1, data: eeprom_buff); |
520 | |
521 | /* Update the checksum over the first part of the EEPROM if needed */ |
522 | if ((ret_val == 0) && (first_word <= EEPROM_CHECKSUM_REG)) |
523 | e1000_update_eeprom_checksum(hw); |
524 | |
525 | kfree(objp: eeprom_buff); |
526 | return ret_val; |
527 | } |
528 | |
529 | static void e1000_get_drvinfo(struct net_device *netdev, |
530 | struct ethtool_drvinfo *drvinfo) |
531 | { |
532 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
533 | |
534 | strscpy(p: drvinfo->driver, q: e1000_driver_name, |
535 | size: sizeof(drvinfo->driver)); |
536 | |
537 | strscpy(p: drvinfo->bus_info, q: pci_name(pdev: adapter->pdev), |
538 | size: sizeof(drvinfo->bus_info)); |
539 | } |
540 | |
541 | static void e1000_get_ringparam(struct net_device *netdev, |
542 | struct ethtool_ringparam *ring, |
543 | struct kernel_ethtool_ringparam *kernel_ring, |
544 | struct netlink_ext_ack *extack) |
545 | { |
546 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
547 | struct e1000_hw *hw = &adapter->hw; |
548 | e1000_mac_type mac_type = hw->mac_type; |
549 | struct e1000_tx_ring *txdr = adapter->tx_ring; |
550 | struct e1000_rx_ring *rxdr = adapter->rx_ring; |
551 | |
552 | ring->rx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_RXD : |
553 | E1000_MAX_82544_RXD; |
554 | ring->tx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_TXD : |
555 | E1000_MAX_82544_TXD; |
556 | ring->rx_pending = rxdr->count; |
557 | ring->tx_pending = txdr->count; |
558 | } |
559 | |
560 | static int e1000_set_ringparam(struct net_device *netdev, |
561 | struct ethtool_ringparam *ring, |
562 | struct kernel_ethtool_ringparam *kernel_ring, |
563 | struct netlink_ext_ack *extack) |
564 | { |
565 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
566 | struct e1000_hw *hw = &adapter->hw; |
567 | e1000_mac_type mac_type = hw->mac_type; |
568 | struct e1000_tx_ring *txdr, *tx_old; |
569 | struct e1000_rx_ring *rxdr, *rx_old; |
570 | int i, err; |
571 | |
572 | if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) |
573 | return -EINVAL; |
574 | |
575 | while (test_and_set_bit(nr: __E1000_RESETTING, addr: &adapter->flags)) |
576 | msleep(msecs: 1); |
577 | |
578 | if (netif_running(dev: adapter->netdev)) |
579 | e1000_down(adapter); |
580 | |
581 | tx_old = adapter->tx_ring; |
582 | rx_old = adapter->rx_ring; |
583 | |
584 | err = -ENOMEM; |
585 | txdr = kcalloc(n: adapter->num_tx_queues, size: sizeof(struct e1000_tx_ring), |
586 | GFP_KERNEL); |
587 | if (!txdr) |
588 | goto err_alloc_tx; |
589 | |
590 | rxdr = kcalloc(n: adapter->num_rx_queues, size: sizeof(struct e1000_rx_ring), |
591 | GFP_KERNEL); |
592 | if (!rxdr) |
593 | goto err_alloc_rx; |
594 | |
595 | adapter->tx_ring = txdr; |
596 | adapter->rx_ring = rxdr; |
597 | |
598 | rxdr->count = max(ring->rx_pending, (u32)E1000_MIN_RXD); |
599 | rxdr->count = min(rxdr->count, (u32)(mac_type < e1000_82544 ? |
600 | E1000_MAX_RXD : E1000_MAX_82544_RXD)); |
601 | rxdr->count = ALIGN(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE); |
602 | txdr->count = max(ring->tx_pending, (u32)E1000_MIN_TXD); |
603 | txdr->count = min(txdr->count, (u32)(mac_type < e1000_82544 ? |
604 | E1000_MAX_TXD : E1000_MAX_82544_TXD)); |
605 | txdr->count = ALIGN(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE); |
606 | |
607 | for (i = 0; i < adapter->num_tx_queues; i++) |
608 | txdr[i].count = txdr->count; |
609 | for (i = 0; i < adapter->num_rx_queues; i++) |
610 | rxdr[i].count = rxdr->count; |
611 | |
612 | err = 0; |
613 | if (netif_running(dev: adapter->netdev)) { |
614 | /* Try to get new resources before deleting old */ |
615 | err = e1000_setup_all_rx_resources(adapter); |
616 | if (err) |
617 | goto err_setup_rx; |
618 | err = e1000_setup_all_tx_resources(adapter); |
619 | if (err) |
620 | goto err_setup_tx; |
621 | |
622 | /* save the new, restore the old in order to free it, |
623 | * then restore the new back again |
624 | */ |
625 | |
626 | adapter->rx_ring = rx_old; |
627 | adapter->tx_ring = tx_old; |
628 | e1000_free_all_rx_resources(adapter); |
629 | e1000_free_all_tx_resources(adapter); |
630 | adapter->rx_ring = rxdr; |
631 | adapter->tx_ring = txdr; |
632 | err = e1000_up(adapter); |
633 | } |
634 | kfree(objp: tx_old); |
635 | kfree(objp: rx_old); |
636 | |
637 | clear_bit(nr: __E1000_RESETTING, addr: &adapter->flags); |
638 | return err; |
639 | |
640 | err_setup_tx: |
641 | e1000_free_all_rx_resources(adapter); |
642 | err_setup_rx: |
643 | adapter->rx_ring = rx_old; |
644 | adapter->tx_ring = tx_old; |
645 | kfree(objp: rxdr); |
646 | err_alloc_rx: |
647 | kfree(objp: txdr); |
648 | err_alloc_tx: |
649 | if (netif_running(dev: adapter->netdev)) |
650 | e1000_up(adapter); |
651 | clear_bit(nr: __E1000_RESETTING, addr: &adapter->flags); |
652 | return err; |
653 | } |
654 | |
655 | static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, int reg, |
656 | u32 mask, u32 write) |
657 | { |
658 | struct e1000_hw *hw = &adapter->hw; |
659 | static const u32 test[] = { |
660 | 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF |
661 | }; |
662 | u8 __iomem *address = hw->hw_addr + reg; |
663 | u32 read; |
664 | int i; |
665 | |
666 | for (i = 0; i < ARRAY_SIZE(test); i++) { |
667 | writel(val: write & test[i], addr: address); |
668 | read = readl(addr: address); |
669 | if (read != (write & test[i] & mask)) { |
670 | e_err(drv, "pattern test reg %04X failed: " |
671 | "got 0x%08X expected 0x%08X\n" , |
672 | reg, read, (write & test[i] & mask)); |
673 | *data = reg; |
674 | return true; |
675 | } |
676 | } |
677 | return false; |
678 | } |
679 | |
680 | static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg, |
681 | u32 mask, u32 write) |
682 | { |
683 | struct e1000_hw *hw = &adapter->hw; |
684 | u8 __iomem *address = hw->hw_addr + reg; |
685 | u32 read; |
686 | |
687 | writel(val: write & mask, addr: address); |
688 | read = readl(addr: address); |
689 | if ((read & mask) != (write & mask)) { |
690 | e_err(drv, "set/check reg %04X test failed: " |
691 | "got 0x%08X expected 0x%08X\n" , |
692 | reg, (read & mask), (write & mask)); |
693 | *data = reg; |
694 | return true; |
695 | } |
696 | return false; |
697 | } |
698 | |
699 | #define REG_PATTERN_TEST(reg, mask, write) \ |
700 | do { \ |
701 | if (reg_pattern_test(adapter, data, \ |
702 | (hw->mac_type >= e1000_82543) \ |
703 | ? E1000_##reg : E1000_82542_##reg, \ |
704 | mask, write)) \ |
705 | return 1; \ |
706 | } while (0) |
707 | |
708 | #define REG_SET_AND_CHECK(reg, mask, write) \ |
709 | do { \ |
710 | if (reg_set_and_check(adapter, data, \ |
711 | (hw->mac_type >= e1000_82543) \ |
712 | ? E1000_##reg : E1000_82542_##reg, \ |
713 | mask, write)) \ |
714 | return 1; \ |
715 | } while (0) |
716 | |
717 | static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data) |
718 | { |
719 | u32 value, before, after; |
720 | u32 i, toggle; |
721 | struct e1000_hw *hw = &adapter->hw; |
722 | |
723 | /* The status register is Read Only, so a write should fail. |
724 | * Some bits that get toggled are ignored. |
725 | */ |
726 | |
727 | /* there are several bits on newer hardware that are r/w */ |
728 | toggle = 0xFFFFF833; |
729 | |
730 | before = er32(STATUS); |
731 | value = (er32(STATUS) & toggle); |
732 | ew32(STATUS, toggle); |
733 | after = er32(STATUS) & toggle; |
734 | if (value != after) { |
735 | e_err(drv, "failed STATUS register test got: " |
736 | "0x%08X expected: 0x%08X\n" , after, value); |
737 | *data = 1; |
738 | return 1; |
739 | } |
740 | /* restore previous status */ |
741 | ew32(STATUS, before); |
742 | |
743 | REG_PATTERN_TEST(FCAL, 0xFFFFFFFF, 0xFFFFFFFF); |
744 | REG_PATTERN_TEST(FCAH, 0x0000FFFF, 0xFFFFFFFF); |
745 | REG_PATTERN_TEST(FCT, 0x0000FFFF, 0xFFFFFFFF); |
746 | REG_PATTERN_TEST(VET, 0x0000FFFF, 0xFFFFFFFF); |
747 | |
748 | REG_PATTERN_TEST(RDTR, 0x0000FFFF, 0xFFFFFFFF); |
749 | REG_PATTERN_TEST(RDBAH, 0xFFFFFFFF, 0xFFFFFFFF); |
750 | REG_PATTERN_TEST(RDLEN, 0x000FFF80, 0x000FFFFF); |
751 | REG_PATTERN_TEST(RDH, 0x0000FFFF, 0x0000FFFF); |
752 | REG_PATTERN_TEST(RDT, 0x0000FFFF, 0x0000FFFF); |
753 | REG_PATTERN_TEST(FCRTH, 0x0000FFF8, 0x0000FFF8); |
754 | REG_PATTERN_TEST(FCTTV, 0x0000FFFF, 0x0000FFFF); |
755 | REG_PATTERN_TEST(TIPG, 0x3FFFFFFF, 0x3FFFFFFF); |
756 | REG_PATTERN_TEST(TDBAH, 0xFFFFFFFF, 0xFFFFFFFF); |
757 | REG_PATTERN_TEST(TDLEN, 0x000FFF80, 0x000FFFFF); |
758 | |
759 | REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x00000000); |
760 | |
761 | before = 0x06DFB3FE; |
762 | REG_SET_AND_CHECK(RCTL, before, 0x003FFFFB); |
763 | REG_SET_AND_CHECK(TCTL, 0xFFFFFFFF, 0x00000000); |
764 | |
765 | if (hw->mac_type >= e1000_82543) { |
766 | REG_SET_AND_CHECK(RCTL, before, 0xFFFFFFFF); |
767 | REG_PATTERN_TEST(RDBAL, 0xFFFFFFF0, 0xFFFFFFFF); |
768 | REG_PATTERN_TEST(TXCW, 0xC000FFFF, 0x0000FFFF); |
769 | REG_PATTERN_TEST(TDBAL, 0xFFFFFFF0, 0xFFFFFFFF); |
770 | REG_PATTERN_TEST(TIDV, 0x0000FFFF, 0x0000FFFF); |
771 | value = E1000_RAR_ENTRIES; |
772 | for (i = 0; i < value; i++) { |
773 | REG_PATTERN_TEST(RA + (((i << 1) + 1) << 2), |
774 | 0x8003FFFF, 0xFFFFFFFF); |
775 | } |
776 | } else { |
777 | REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x01FFFFFF); |
778 | REG_PATTERN_TEST(RDBAL, 0xFFFFF000, 0xFFFFFFFF); |
779 | REG_PATTERN_TEST(TXCW, 0x0000FFFF, 0x0000FFFF); |
780 | REG_PATTERN_TEST(TDBAL, 0xFFFFF000, 0xFFFFFFFF); |
781 | } |
782 | |
783 | value = E1000_MC_TBL_SIZE; |
784 | for (i = 0; i < value; i++) |
785 | REG_PATTERN_TEST(MTA + (i << 2), 0xFFFFFFFF, 0xFFFFFFFF); |
786 | |
787 | *data = 0; |
788 | return 0; |
789 | } |
790 | |
791 | static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data) |
792 | { |
793 | struct e1000_hw *hw = &adapter->hw; |
794 | u16 temp; |
795 | u16 checksum = 0; |
796 | u16 i; |
797 | |
798 | *data = 0; |
799 | /* Read and add up the contents of the EEPROM */ |
800 | for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) { |
801 | if ((e1000_read_eeprom(hw, reg: i, words: 1, data: &temp)) < 0) { |
802 | *data = 1; |
803 | break; |
804 | } |
805 | checksum += temp; |
806 | } |
807 | |
808 | /* If Checksum is not Correct return error else test passed */ |
809 | if ((checksum != (u16)EEPROM_SUM) && !(*data)) |
810 | *data = 2; |
811 | |
812 | return *data; |
813 | } |
814 | |
815 | static irqreturn_t e1000_test_intr(int irq, void *data) |
816 | { |
817 | struct net_device *netdev = (struct net_device *)data; |
818 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
819 | struct e1000_hw *hw = &adapter->hw; |
820 | |
821 | adapter->test_icr |= er32(ICR); |
822 | |
823 | return IRQ_HANDLED; |
824 | } |
825 | |
826 | static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data) |
827 | { |
828 | struct net_device *netdev = adapter->netdev; |
829 | u32 mask, i = 0; |
830 | bool shared_int = true; |
831 | u32 irq = adapter->pdev->irq; |
832 | struct e1000_hw *hw = &adapter->hw; |
833 | |
834 | *data = 0; |
835 | |
836 | /* NOTE: we don't test MSI interrupts here, yet |
837 | * Hook up test interrupt handler just for this test |
838 | */ |
839 | if (!request_irq(irq, handler: e1000_test_intr, IRQF_PROBE_SHARED, name: netdev->name, |
840 | dev: netdev)) |
841 | shared_int = false; |
842 | else if (request_irq(irq, handler: e1000_test_intr, IRQF_SHARED, |
843 | name: netdev->name, dev: netdev)) { |
844 | *data = 1; |
845 | return -1; |
846 | } |
847 | e_info(hw, "testing %s interrupt\n" , (shared_int ? |
848 | "shared" : "unshared" )); |
849 | |
850 | /* Disable all the interrupts */ |
851 | ew32(IMC, 0xFFFFFFFF); |
852 | E1000_WRITE_FLUSH(); |
853 | msleep(msecs: 10); |
854 | |
855 | /* Test each interrupt */ |
856 | for (; i < 10; i++) { |
857 | /* Interrupt to test */ |
858 | mask = 1 << i; |
859 | |
860 | if (!shared_int) { |
861 | /* Disable the interrupt to be reported in |
862 | * the cause register and then force the same |
863 | * interrupt and see if one gets posted. If |
864 | * an interrupt was posted to the bus, the |
865 | * test failed. |
866 | */ |
867 | adapter->test_icr = 0; |
868 | ew32(IMC, mask); |
869 | ew32(ICS, mask); |
870 | E1000_WRITE_FLUSH(); |
871 | msleep(msecs: 10); |
872 | |
873 | if (adapter->test_icr & mask) { |
874 | *data = 3; |
875 | break; |
876 | } |
877 | } |
878 | |
879 | /* Enable the interrupt to be reported in |
880 | * the cause register and then force the same |
881 | * interrupt and see if one gets posted. If |
882 | * an interrupt was not posted to the bus, the |
883 | * test failed. |
884 | */ |
885 | adapter->test_icr = 0; |
886 | ew32(IMS, mask); |
887 | ew32(ICS, mask); |
888 | E1000_WRITE_FLUSH(); |
889 | msleep(msecs: 10); |
890 | |
891 | if (!(adapter->test_icr & mask)) { |
892 | *data = 4; |
893 | break; |
894 | } |
895 | |
896 | if (!shared_int) { |
897 | /* Disable the other interrupts to be reported in |
898 | * the cause register and then force the other |
899 | * interrupts and see if any get posted. If |
900 | * an interrupt was posted to the bus, the |
901 | * test failed. |
902 | */ |
903 | adapter->test_icr = 0; |
904 | ew32(IMC, ~mask & 0x00007FFF); |
905 | ew32(ICS, ~mask & 0x00007FFF); |
906 | E1000_WRITE_FLUSH(); |
907 | msleep(msecs: 10); |
908 | |
909 | if (adapter->test_icr) { |
910 | *data = 5; |
911 | break; |
912 | } |
913 | } |
914 | } |
915 | |
916 | /* Disable all the interrupts */ |
917 | ew32(IMC, 0xFFFFFFFF); |
918 | E1000_WRITE_FLUSH(); |
919 | msleep(msecs: 10); |
920 | |
921 | /* Unhook test interrupt handler */ |
922 | free_irq(irq, netdev); |
923 | |
924 | return *data; |
925 | } |
926 | |
927 | static void e1000_free_desc_rings(struct e1000_adapter *adapter) |
928 | { |
929 | struct e1000_tx_ring *txdr = &adapter->test_tx_ring; |
930 | struct e1000_rx_ring *rxdr = &adapter->test_rx_ring; |
931 | struct pci_dev *pdev = adapter->pdev; |
932 | int i; |
933 | |
934 | if (txdr->desc && txdr->buffer_info) { |
935 | for (i = 0; i < txdr->count; i++) { |
936 | if (txdr->buffer_info[i].dma) |
937 | dma_unmap_single(&pdev->dev, |
938 | txdr->buffer_info[i].dma, |
939 | txdr->buffer_info[i].length, |
940 | DMA_TO_DEVICE); |
941 | dev_kfree_skb(txdr->buffer_info[i].skb); |
942 | } |
943 | } |
944 | |
945 | if (rxdr->desc && rxdr->buffer_info) { |
946 | for (i = 0; i < rxdr->count; i++) { |
947 | if (rxdr->buffer_info[i].dma) |
948 | dma_unmap_single(&pdev->dev, |
949 | rxdr->buffer_info[i].dma, |
950 | E1000_RXBUFFER_2048, |
951 | DMA_FROM_DEVICE); |
952 | kfree(objp: rxdr->buffer_info[i].rxbuf.data); |
953 | } |
954 | } |
955 | |
956 | if (txdr->desc) { |
957 | dma_free_coherent(dev: &pdev->dev, size: txdr->size, cpu_addr: txdr->desc, |
958 | dma_handle: txdr->dma); |
959 | txdr->desc = NULL; |
960 | } |
961 | if (rxdr->desc) { |
962 | dma_free_coherent(dev: &pdev->dev, size: rxdr->size, cpu_addr: rxdr->desc, |
963 | dma_handle: rxdr->dma); |
964 | rxdr->desc = NULL; |
965 | } |
966 | |
967 | kfree(objp: txdr->buffer_info); |
968 | txdr->buffer_info = NULL; |
969 | kfree(objp: rxdr->buffer_info); |
970 | rxdr->buffer_info = NULL; |
971 | } |
972 | |
973 | static int e1000_setup_desc_rings(struct e1000_adapter *adapter) |
974 | { |
975 | struct e1000_hw *hw = &adapter->hw; |
976 | struct e1000_tx_ring *txdr = &adapter->test_tx_ring; |
977 | struct e1000_rx_ring *rxdr = &adapter->test_rx_ring; |
978 | struct pci_dev *pdev = adapter->pdev; |
979 | u32 rctl; |
980 | int i, ret_val; |
981 | |
982 | /* Setup Tx descriptor ring and Tx buffers */ |
983 | |
984 | if (!txdr->count) |
985 | txdr->count = E1000_DEFAULT_TXD; |
986 | |
987 | txdr->buffer_info = kcalloc(n: txdr->count, size: sizeof(struct e1000_tx_buffer), |
988 | GFP_KERNEL); |
989 | if (!txdr->buffer_info) { |
990 | ret_val = 1; |
991 | goto err_nomem; |
992 | } |
993 | |
994 | txdr->size = txdr->count * sizeof(struct e1000_tx_desc); |
995 | txdr->size = ALIGN(txdr->size, 4096); |
996 | txdr->desc = dma_alloc_coherent(dev: &pdev->dev, size: txdr->size, dma_handle: &txdr->dma, |
997 | GFP_KERNEL); |
998 | if (!txdr->desc) { |
999 | ret_val = 2; |
1000 | goto err_nomem; |
1001 | } |
1002 | txdr->next_to_use = txdr->next_to_clean = 0; |
1003 | |
1004 | ew32(TDBAL, ((u64)txdr->dma & 0x00000000FFFFFFFF)); |
1005 | ew32(TDBAH, ((u64)txdr->dma >> 32)); |
1006 | ew32(TDLEN, txdr->count * sizeof(struct e1000_tx_desc)); |
1007 | ew32(TDH, 0); |
1008 | ew32(TDT, 0); |
1009 | ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | |
1010 | E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT | |
1011 | E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT); |
1012 | |
1013 | for (i = 0; i < txdr->count; i++) { |
1014 | struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*txdr, i); |
1015 | struct sk_buff *skb; |
1016 | unsigned int size = 1024; |
1017 | |
1018 | skb = alloc_skb(size, GFP_KERNEL); |
1019 | if (!skb) { |
1020 | ret_val = 3; |
1021 | goto err_nomem; |
1022 | } |
1023 | skb_put(skb, len: size); |
1024 | txdr->buffer_info[i].skb = skb; |
1025 | txdr->buffer_info[i].length = skb->len; |
1026 | txdr->buffer_info[i].dma = |
1027 | dma_map_single(&pdev->dev, skb->data, skb->len, |
1028 | DMA_TO_DEVICE); |
1029 | if (dma_mapping_error(dev: &pdev->dev, dma_addr: txdr->buffer_info[i].dma)) { |
1030 | ret_val = 4; |
1031 | goto err_nomem; |
1032 | } |
1033 | tx_desc->buffer_addr = cpu_to_le64(txdr->buffer_info[i].dma); |
1034 | tx_desc->lower.data = cpu_to_le32(skb->len); |
1035 | tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP | |
1036 | E1000_TXD_CMD_IFCS | |
1037 | E1000_TXD_CMD_RPS); |
1038 | tx_desc->upper.data = 0; |
1039 | } |
1040 | |
1041 | /* Setup Rx descriptor ring and Rx buffers */ |
1042 | |
1043 | if (!rxdr->count) |
1044 | rxdr->count = E1000_DEFAULT_RXD; |
1045 | |
1046 | rxdr->buffer_info = kcalloc(n: rxdr->count, size: sizeof(struct e1000_rx_buffer), |
1047 | GFP_KERNEL); |
1048 | if (!rxdr->buffer_info) { |
1049 | ret_val = 5; |
1050 | goto err_nomem; |
1051 | } |
1052 | |
1053 | rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc); |
1054 | rxdr->desc = dma_alloc_coherent(dev: &pdev->dev, size: rxdr->size, dma_handle: &rxdr->dma, |
1055 | GFP_KERNEL); |
1056 | if (!rxdr->desc) { |
1057 | ret_val = 6; |
1058 | goto err_nomem; |
1059 | } |
1060 | rxdr->next_to_use = rxdr->next_to_clean = 0; |
1061 | |
1062 | rctl = er32(RCTL); |
1063 | ew32(RCTL, rctl & ~E1000_RCTL_EN); |
1064 | ew32(RDBAL, ((u64)rxdr->dma & 0xFFFFFFFF)); |
1065 | ew32(RDBAH, ((u64)rxdr->dma >> 32)); |
1066 | ew32(RDLEN, rxdr->size); |
1067 | ew32(RDH, 0); |
1068 | ew32(RDT, 0); |
1069 | rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 | |
1070 | E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF | |
1071 | (hw->mc_filter_type << E1000_RCTL_MO_SHIFT); |
1072 | ew32(RCTL, rctl); |
1073 | |
1074 | for (i = 0; i < rxdr->count; i++) { |
1075 | struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rxdr, i); |
1076 | u8 *buf; |
1077 | |
1078 | buf = kzalloc(E1000_RXBUFFER_2048 + NET_SKB_PAD + NET_IP_ALIGN, |
1079 | GFP_KERNEL); |
1080 | if (!buf) { |
1081 | ret_val = 7; |
1082 | goto err_nomem; |
1083 | } |
1084 | rxdr->buffer_info[i].rxbuf.data = buf; |
1085 | |
1086 | rxdr->buffer_info[i].dma = |
1087 | dma_map_single(&pdev->dev, |
1088 | buf + NET_SKB_PAD + NET_IP_ALIGN, |
1089 | E1000_RXBUFFER_2048, DMA_FROM_DEVICE); |
1090 | if (dma_mapping_error(dev: &pdev->dev, dma_addr: rxdr->buffer_info[i].dma)) { |
1091 | ret_val = 8; |
1092 | goto err_nomem; |
1093 | } |
1094 | rx_desc->buffer_addr = cpu_to_le64(rxdr->buffer_info[i].dma); |
1095 | } |
1096 | |
1097 | return 0; |
1098 | |
1099 | err_nomem: |
1100 | e1000_free_desc_rings(adapter); |
1101 | return ret_val; |
1102 | } |
1103 | |
1104 | static void e1000_phy_disable_receiver(struct e1000_adapter *adapter) |
1105 | { |
1106 | struct e1000_hw *hw = &adapter->hw; |
1107 | |
1108 | /* Write out to PHY registers 29 and 30 to disable the Receiver. */ |
1109 | e1000_write_phy_reg(hw, reg_addr: 29, data: 0x001F); |
1110 | e1000_write_phy_reg(hw, reg_addr: 30, data: 0x8FFC); |
1111 | e1000_write_phy_reg(hw, reg_addr: 29, data: 0x001A); |
1112 | e1000_write_phy_reg(hw, reg_addr: 30, data: 0x8FF0); |
1113 | } |
1114 | |
1115 | static void e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter) |
1116 | { |
1117 | struct e1000_hw *hw = &adapter->hw; |
1118 | u16 phy_reg; |
1119 | |
1120 | /* Because we reset the PHY above, we need to re-force TX_CLK in the |
1121 | * Extended PHY Specific Control Register to 25MHz clock. This |
1122 | * value defaults back to a 2.5MHz clock when the PHY is reset. |
1123 | */ |
1124 | e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data: &phy_reg); |
1125 | phy_reg |= M88E1000_EPSCR_TX_CLK_25; |
1126 | e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, data: phy_reg); |
1127 | |
1128 | /* In addition, because of the s/w reset above, we need to enable |
1129 | * CRS on TX. This must be set for both full and half duplex |
1130 | * operation. |
1131 | */ |
1132 | e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data: &phy_reg); |
1133 | phy_reg |= M88E1000_PSCR_ASSERT_CRS_ON_TX; |
1134 | e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, data: phy_reg); |
1135 | } |
1136 | |
1137 | static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter) |
1138 | { |
1139 | struct e1000_hw *hw = &adapter->hw; |
1140 | u32 ctrl_reg; |
1141 | u16 phy_reg; |
1142 | |
1143 | /* Setup the Device Control Register for PHY loopback test. */ |
1144 | |
1145 | ctrl_reg = er32(CTRL); |
1146 | ctrl_reg |= (E1000_CTRL_ILOS | /* Invert Loss-Of-Signal */ |
1147 | E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */ |
1148 | E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */ |
1149 | E1000_CTRL_SPD_1000 | /* Force Speed to 1000 */ |
1150 | E1000_CTRL_FD); /* Force Duplex to FULL */ |
1151 | |
1152 | ew32(CTRL, ctrl_reg); |
1153 | |
1154 | /* Read the PHY Specific Control Register (0x10) */ |
1155 | e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data: &phy_reg); |
1156 | |
1157 | /* Clear Auto-Crossover bits in PHY Specific Control Register |
1158 | * (bits 6:5). |
1159 | */ |
1160 | phy_reg &= ~M88E1000_PSCR_AUTO_X_MODE; |
1161 | e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, data: phy_reg); |
1162 | |
1163 | /* Perform software reset on the PHY */ |
1164 | e1000_phy_reset(hw); |
1165 | |
1166 | /* Have to setup TX_CLK and TX_CRS after software reset */ |
1167 | e1000_phy_reset_clk_and_crs(adapter); |
1168 | |
1169 | e1000_write_phy_reg(hw, PHY_CTRL, data: 0x8100); |
1170 | |
1171 | /* Wait for reset to complete. */ |
1172 | udelay(500); |
1173 | |
1174 | /* Have to setup TX_CLK and TX_CRS after software reset */ |
1175 | e1000_phy_reset_clk_and_crs(adapter); |
1176 | |
1177 | /* Write out to PHY registers 29 and 30 to disable the Receiver. */ |
1178 | e1000_phy_disable_receiver(adapter); |
1179 | |
1180 | /* Set the loopback bit in the PHY control register. */ |
1181 | e1000_read_phy_reg(hw, PHY_CTRL, phy_data: &phy_reg); |
1182 | phy_reg |= MII_CR_LOOPBACK; |
1183 | e1000_write_phy_reg(hw, PHY_CTRL, data: phy_reg); |
1184 | |
1185 | /* Setup TX_CLK and TX_CRS one more time. */ |
1186 | e1000_phy_reset_clk_and_crs(adapter); |
1187 | |
1188 | /* Check Phy Configuration */ |
1189 | e1000_read_phy_reg(hw, PHY_CTRL, phy_data: &phy_reg); |
1190 | if (phy_reg != 0x4100) |
1191 | return 9; |
1192 | |
1193 | e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_data: &phy_reg); |
1194 | if (phy_reg != 0x0070) |
1195 | return 10; |
1196 | |
1197 | e1000_read_phy_reg(hw, reg_addr: 29, phy_data: &phy_reg); |
1198 | if (phy_reg != 0x001A) |
1199 | return 11; |
1200 | |
1201 | return 0; |
1202 | } |
1203 | |
1204 | static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter) |
1205 | { |
1206 | struct e1000_hw *hw = &adapter->hw; |
1207 | u32 ctrl_reg = 0; |
1208 | u32 stat_reg = 0; |
1209 | |
1210 | hw->autoneg = false; |
1211 | |
1212 | if (hw->phy_type == e1000_phy_m88) { |
1213 | /* Auto-MDI/MDIX Off */ |
1214 | e1000_write_phy_reg(hw, |
1215 | M88E1000_PHY_SPEC_CTRL, data: 0x0808); |
1216 | /* reset to update Auto-MDI/MDIX */ |
1217 | e1000_write_phy_reg(hw, PHY_CTRL, data: 0x9140); |
1218 | /* autoneg off */ |
1219 | e1000_write_phy_reg(hw, PHY_CTRL, data: 0x8140); |
1220 | } |
1221 | |
1222 | ctrl_reg = er32(CTRL); |
1223 | |
1224 | /* force 1000, set loopback */ |
1225 | e1000_write_phy_reg(hw, PHY_CTRL, data: 0x4140); |
1226 | |
1227 | /* Now set up the MAC to the same speed/duplex as the PHY. */ |
1228 | ctrl_reg = er32(CTRL); |
1229 | ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */ |
1230 | ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */ |
1231 | E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */ |
1232 | E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */ |
1233 | E1000_CTRL_FD); /* Force Duplex to FULL */ |
1234 | |
1235 | if (hw->media_type == e1000_media_type_copper && |
1236 | hw->phy_type == e1000_phy_m88) |
1237 | ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */ |
1238 | else { |
1239 | /* Set the ILOS bit on the fiber Nic is half |
1240 | * duplex link is detected. |
1241 | */ |
1242 | stat_reg = er32(STATUS); |
1243 | if ((stat_reg & E1000_STATUS_FD) == 0) |
1244 | ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU); |
1245 | } |
1246 | |
1247 | ew32(CTRL, ctrl_reg); |
1248 | |
1249 | /* Disable the receiver on the PHY so when a cable is plugged in, the |
1250 | * PHY does not begin to autoneg when a cable is reconnected to the NIC. |
1251 | */ |
1252 | if (hw->phy_type == e1000_phy_m88) |
1253 | e1000_phy_disable_receiver(adapter); |
1254 | |
1255 | udelay(500); |
1256 | |
1257 | return 0; |
1258 | } |
1259 | |
1260 | static int e1000_set_phy_loopback(struct e1000_adapter *adapter) |
1261 | { |
1262 | struct e1000_hw *hw = &adapter->hw; |
1263 | u16 phy_reg = 0; |
1264 | u16 count = 0; |
1265 | |
1266 | switch (hw->mac_type) { |
1267 | case e1000_82543: |
1268 | if (hw->media_type == e1000_media_type_copper) { |
1269 | /* Attempt to setup Loopback mode on Non-integrated PHY. |
1270 | * Some PHY registers get corrupted at random, so |
1271 | * attempt this 10 times. |
1272 | */ |
1273 | while (e1000_nonintegrated_phy_loopback(adapter) && |
1274 | count++ < 10); |
1275 | if (count < 11) |
1276 | return 0; |
1277 | } |
1278 | break; |
1279 | |
1280 | case e1000_82544: |
1281 | case e1000_82540: |
1282 | case e1000_82545: |
1283 | case e1000_82545_rev_3: |
1284 | case e1000_82546: |
1285 | case e1000_82546_rev_3: |
1286 | case e1000_82541: |
1287 | case e1000_82541_rev_2: |
1288 | case e1000_82547: |
1289 | case e1000_82547_rev_2: |
1290 | return e1000_integrated_phy_loopback(adapter); |
1291 | default: |
1292 | /* Default PHY loopback work is to read the MII |
1293 | * control register and assert bit 14 (loopback mode). |
1294 | */ |
1295 | e1000_read_phy_reg(hw, PHY_CTRL, phy_data: &phy_reg); |
1296 | phy_reg |= MII_CR_LOOPBACK; |
1297 | e1000_write_phy_reg(hw, PHY_CTRL, data: phy_reg); |
1298 | return 0; |
1299 | } |
1300 | |
1301 | return 8; |
1302 | } |
1303 | |
1304 | static int e1000_setup_loopback_test(struct e1000_adapter *adapter) |
1305 | { |
1306 | struct e1000_hw *hw = &adapter->hw; |
1307 | u32 rctl; |
1308 | |
1309 | if (hw->media_type == e1000_media_type_fiber || |
1310 | hw->media_type == e1000_media_type_internal_serdes) { |
1311 | switch (hw->mac_type) { |
1312 | case e1000_82545: |
1313 | case e1000_82546: |
1314 | case e1000_82545_rev_3: |
1315 | case e1000_82546_rev_3: |
1316 | return e1000_set_phy_loopback(adapter); |
1317 | default: |
1318 | rctl = er32(RCTL); |
1319 | rctl |= E1000_RCTL_LBM_TCVR; |
1320 | ew32(RCTL, rctl); |
1321 | return 0; |
1322 | } |
1323 | } else if (hw->media_type == e1000_media_type_copper) { |
1324 | return e1000_set_phy_loopback(adapter); |
1325 | } |
1326 | |
1327 | return 7; |
1328 | } |
1329 | |
1330 | static void e1000_loopback_cleanup(struct e1000_adapter *adapter) |
1331 | { |
1332 | struct e1000_hw *hw = &adapter->hw; |
1333 | u32 rctl; |
1334 | u16 phy_reg; |
1335 | |
1336 | rctl = er32(RCTL); |
1337 | rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC); |
1338 | ew32(RCTL, rctl); |
1339 | |
1340 | switch (hw->mac_type) { |
1341 | case e1000_82545: |
1342 | case e1000_82546: |
1343 | case e1000_82545_rev_3: |
1344 | case e1000_82546_rev_3: |
1345 | default: |
1346 | hw->autoneg = true; |
1347 | e1000_read_phy_reg(hw, PHY_CTRL, phy_data: &phy_reg); |
1348 | if (phy_reg & MII_CR_LOOPBACK) { |
1349 | phy_reg &= ~MII_CR_LOOPBACK; |
1350 | e1000_write_phy_reg(hw, PHY_CTRL, data: phy_reg); |
1351 | e1000_phy_reset(hw); |
1352 | } |
1353 | break; |
1354 | } |
1355 | } |
1356 | |
1357 | static void e1000_create_lbtest_frame(struct sk_buff *skb, |
1358 | unsigned int frame_size) |
1359 | { |
1360 | memset(skb->data, 0xFF, frame_size); |
1361 | frame_size &= ~1; |
1362 | memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1); |
1363 | skb->data[frame_size / 2 + 10] = 0xBE; |
1364 | skb->data[frame_size / 2 + 12] = 0xAF; |
1365 | } |
1366 | |
1367 | static int e1000_check_lbtest_frame(const unsigned char *data, |
1368 | unsigned int frame_size) |
1369 | { |
1370 | frame_size &= ~1; |
1371 | if (*(data + 3) == 0xFF) { |
1372 | if ((*(data + frame_size / 2 + 10) == 0xBE) && |
1373 | (*(data + frame_size / 2 + 12) == 0xAF)) { |
1374 | return 0; |
1375 | } |
1376 | } |
1377 | return 13; |
1378 | } |
1379 | |
1380 | static int e1000_run_loopback_test(struct e1000_adapter *adapter) |
1381 | { |
1382 | struct e1000_hw *hw = &adapter->hw; |
1383 | struct e1000_tx_ring *txdr = &adapter->test_tx_ring; |
1384 | struct e1000_rx_ring *rxdr = &adapter->test_rx_ring; |
1385 | struct pci_dev *pdev = adapter->pdev; |
1386 | int i, j, k, l, lc, good_cnt, ret_val = 0; |
1387 | unsigned long time; |
1388 | |
1389 | ew32(RDT, rxdr->count - 1); |
1390 | |
1391 | /* Calculate the loop count based on the largest descriptor ring |
1392 | * The idea is to wrap the largest ring a number of times using 64 |
1393 | * send/receive pairs during each loop |
1394 | */ |
1395 | |
1396 | if (rxdr->count <= txdr->count) |
1397 | lc = ((txdr->count / 64) * 2) + 1; |
1398 | else |
1399 | lc = ((rxdr->count / 64) * 2) + 1; |
1400 | |
1401 | k = l = 0; |
1402 | for (j = 0; j <= lc; j++) { /* loop count loop */ |
1403 | for (i = 0; i < 64; i++) { /* send the packets */ |
1404 | e1000_create_lbtest_frame(skb: txdr->buffer_info[i].skb, |
1405 | frame_size: 1024); |
1406 | dma_sync_single_for_device(dev: &pdev->dev, |
1407 | addr: txdr->buffer_info[k].dma, |
1408 | size: txdr->buffer_info[k].length, |
1409 | dir: DMA_TO_DEVICE); |
1410 | if (unlikely(++k == txdr->count)) |
1411 | k = 0; |
1412 | } |
1413 | ew32(TDT, k); |
1414 | E1000_WRITE_FLUSH(); |
1415 | msleep(msecs: 200); |
1416 | time = jiffies; /* set the start time for the receive */ |
1417 | good_cnt = 0; |
1418 | do { /* receive the sent packets */ |
1419 | dma_sync_single_for_cpu(dev: &pdev->dev, |
1420 | addr: rxdr->buffer_info[l].dma, |
1421 | E1000_RXBUFFER_2048, |
1422 | dir: DMA_FROM_DEVICE); |
1423 | |
1424 | ret_val = e1000_check_lbtest_frame( |
1425 | data: rxdr->buffer_info[l].rxbuf.data + |
1426 | NET_SKB_PAD + NET_IP_ALIGN, |
1427 | frame_size: 1024); |
1428 | if (!ret_val) |
1429 | good_cnt++; |
1430 | if (unlikely(++l == rxdr->count)) |
1431 | l = 0; |
1432 | /* time + 20 msecs (200 msecs on 2.4) is more than |
1433 | * enough time to complete the receives, if it's |
1434 | * exceeded, break and error off |
1435 | */ |
1436 | } while (good_cnt < 64 && time_after(time + 20, jiffies)); |
1437 | |
1438 | if (good_cnt != 64) { |
1439 | ret_val = 13; /* ret_val is the same as mis-compare */ |
1440 | break; |
1441 | } |
1442 | if (time_after_eq(jiffies, time + 2)) { |
1443 | ret_val = 14; /* error code for time out error */ |
1444 | break; |
1445 | } |
1446 | } /* end loop count loop */ |
1447 | return ret_val; |
1448 | } |
1449 | |
1450 | static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data) |
1451 | { |
1452 | *data = e1000_setup_desc_rings(adapter); |
1453 | if (*data) |
1454 | goto out; |
1455 | *data = e1000_setup_loopback_test(adapter); |
1456 | if (*data) |
1457 | goto err_loopback; |
1458 | *data = e1000_run_loopback_test(adapter); |
1459 | e1000_loopback_cleanup(adapter); |
1460 | |
1461 | err_loopback: |
1462 | e1000_free_desc_rings(adapter); |
1463 | out: |
1464 | return *data; |
1465 | } |
1466 | |
1467 | static int e1000_link_test(struct e1000_adapter *adapter, u64 *data) |
1468 | { |
1469 | struct e1000_hw *hw = &adapter->hw; |
1470 | *data = 0; |
1471 | if (hw->media_type == e1000_media_type_internal_serdes) { |
1472 | int i = 0; |
1473 | |
1474 | hw->serdes_has_link = false; |
1475 | |
1476 | /* On some blade server designs, link establishment |
1477 | * could take as long as 2-3 minutes |
1478 | */ |
1479 | do { |
1480 | e1000_check_for_link(hw); |
1481 | if (hw->serdes_has_link) |
1482 | return *data; |
1483 | msleep(msecs: 20); |
1484 | } while (i++ < 3750); |
1485 | |
1486 | *data = 1; |
1487 | } else { |
1488 | e1000_check_for_link(hw); |
1489 | if (hw->autoneg) /* if auto_neg is set wait for it */ |
1490 | msleep(msecs: 4000); |
1491 | |
1492 | if (!(er32(STATUS) & E1000_STATUS_LU)) |
1493 | *data = 1; |
1494 | } |
1495 | return *data; |
1496 | } |
1497 | |
1498 | static int e1000_get_sset_count(struct net_device *netdev, int sset) |
1499 | { |
1500 | switch (sset) { |
1501 | case ETH_SS_TEST: |
1502 | return E1000_TEST_LEN; |
1503 | case ETH_SS_STATS: |
1504 | return E1000_STATS_LEN; |
1505 | default: |
1506 | return -EOPNOTSUPP; |
1507 | } |
1508 | } |
1509 | |
1510 | static void e1000_diag_test(struct net_device *netdev, |
1511 | struct ethtool_test *eth_test, u64 *data) |
1512 | { |
1513 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1514 | struct e1000_hw *hw = &adapter->hw; |
1515 | bool if_running = netif_running(dev: netdev); |
1516 | |
1517 | set_bit(nr: __E1000_TESTING, addr: &adapter->flags); |
1518 | if (eth_test->flags == ETH_TEST_FL_OFFLINE) { |
1519 | /* Offline tests */ |
1520 | |
1521 | /* save speed, duplex, autoneg settings */ |
1522 | u16 autoneg_advertised = hw->autoneg_advertised; |
1523 | u8 forced_speed_duplex = hw->forced_speed_duplex; |
1524 | u8 autoneg = hw->autoneg; |
1525 | |
1526 | e_info(hw, "offline testing starting\n" ); |
1527 | |
1528 | /* Link test performed before hardware reset so autoneg doesn't |
1529 | * interfere with test result |
1530 | */ |
1531 | if (e1000_link_test(adapter, data: &data[4])) |
1532 | eth_test->flags |= ETH_TEST_FL_FAILED; |
1533 | |
1534 | if (if_running) |
1535 | /* indicate we're in test mode */ |
1536 | e1000_close(netdev); |
1537 | else |
1538 | e1000_reset(adapter); |
1539 | |
1540 | if (e1000_reg_test(adapter, data: &data[0])) |
1541 | eth_test->flags |= ETH_TEST_FL_FAILED; |
1542 | |
1543 | e1000_reset(adapter); |
1544 | if (e1000_eeprom_test(adapter, data: &data[1])) |
1545 | eth_test->flags |= ETH_TEST_FL_FAILED; |
1546 | |
1547 | e1000_reset(adapter); |
1548 | if (e1000_intr_test(adapter, data: &data[2])) |
1549 | eth_test->flags |= ETH_TEST_FL_FAILED; |
1550 | |
1551 | e1000_reset(adapter); |
1552 | /* make sure the phy is powered up */ |
1553 | e1000_power_up_phy(adapter); |
1554 | if (e1000_loopback_test(adapter, data: &data[3])) |
1555 | eth_test->flags |= ETH_TEST_FL_FAILED; |
1556 | |
1557 | /* restore speed, duplex, autoneg settings */ |
1558 | hw->autoneg_advertised = autoneg_advertised; |
1559 | hw->forced_speed_duplex = forced_speed_duplex; |
1560 | hw->autoneg = autoneg; |
1561 | |
1562 | e1000_reset(adapter); |
1563 | clear_bit(nr: __E1000_TESTING, addr: &adapter->flags); |
1564 | if (if_running) |
1565 | e1000_open(netdev); |
1566 | } else { |
1567 | e_info(hw, "online testing starting\n" ); |
1568 | /* Online tests */ |
1569 | if (e1000_link_test(adapter, data: &data[4])) |
1570 | eth_test->flags |= ETH_TEST_FL_FAILED; |
1571 | |
1572 | /* Online tests aren't run; pass by default */ |
1573 | data[0] = 0; |
1574 | data[1] = 0; |
1575 | data[2] = 0; |
1576 | data[3] = 0; |
1577 | |
1578 | clear_bit(nr: __E1000_TESTING, addr: &adapter->flags); |
1579 | } |
1580 | msleep_interruptible(msecs: 4 * 1000); |
1581 | } |
1582 | |
1583 | static int e1000_wol_exclusion(struct e1000_adapter *adapter, |
1584 | struct ethtool_wolinfo *wol) |
1585 | { |
1586 | struct e1000_hw *hw = &adapter->hw; |
1587 | int retval = 1; /* fail by default */ |
1588 | |
1589 | switch (hw->device_id) { |
1590 | case E1000_DEV_ID_82542: |
1591 | case E1000_DEV_ID_82543GC_FIBER: |
1592 | case E1000_DEV_ID_82543GC_COPPER: |
1593 | case E1000_DEV_ID_82544EI_FIBER: |
1594 | case E1000_DEV_ID_82546EB_QUAD_COPPER: |
1595 | case E1000_DEV_ID_82545EM_FIBER: |
1596 | case E1000_DEV_ID_82545EM_COPPER: |
1597 | case E1000_DEV_ID_82546GB_QUAD_COPPER: |
1598 | case E1000_DEV_ID_82546GB_PCIE: |
1599 | /* these don't support WoL at all */ |
1600 | wol->supported = 0; |
1601 | break; |
1602 | case E1000_DEV_ID_82546EB_FIBER: |
1603 | case E1000_DEV_ID_82546GB_FIBER: |
1604 | /* Wake events not supported on port B */ |
1605 | if (er32(STATUS) & E1000_STATUS_FUNC_1) { |
1606 | wol->supported = 0; |
1607 | break; |
1608 | } |
1609 | /* return success for non excluded adapter ports */ |
1610 | retval = 0; |
1611 | break; |
1612 | case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3: |
1613 | /* quad port adapters only support WoL on port A */ |
1614 | if (!adapter->quad_port_a) { |
1615 | wol->supported = 0; |
1616 | break; |
1617 | } |
1618 | /* return success for non excluded adapter ports */ |
1619 | retval = 0; |
1620 | break; |
1621 | default: |
1622 | /* dual port cards only support WoL on port A from now on |
1623 | * unless it was enabled in the eeprom for port B |
1624 | * so exclude FUNC_1 ports from having WoL enabled |
1625 | */ |
1626 | if (er32(STATUS) & E1000_STATUS_FUNC_1 && |
1627 | !adapter->eeprom_wol) { |
1628 | wol->supported = 0; |
1629 | break; |
1630 | } |
1631 | |
1632 | retval = 0; |
1633 | } |
1634 | |
1635 | return retval; |
1636 | } |
1637 | |
1638 | static void e1000_get_wol(struct net_device *netdev, |
1639 | struct ethtool_wolinfo *wol) |
1640 | { |
1641 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1642 | struct e1000_hw *hw = &adapter->hw; |
1643 | |
1644 | wol->supported = WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | WAKE_MAGIC; |
1645 | wol->wolopts = 0; |
1646 | |
1647 | /* this function will set ->supported = 0 and return 1 if wol is not |
1648 | * supported by this hardware |
1649 | */ |
1650 | if (e1000_wol_exclusion(adapter, wol) || |
1651 | !device_can_wakeup(dev: &adapter->pdev->dev)) |
1652 | return; |
1653 | |
1654 | /* apply any specific unsupported masks here */ |
1655 | switch (hw->device_id) { |
1656 | case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3: |
1657 | /* KSP3 does not support UCAST wake-ups */ |
1658 | wol->supported &= ~WAKE_UCAST; |
1659 | |
1660 | if (adapter->wol & E1000_WUFC_EX) |
1661 | e_err(drv, "Interface does not support directed " |
1662 | "(unicast) frame wake-up packets\n" ); |
1663 | break; |
1664 | default: |
1665 | break; |
1666 | } |
1667 | |
1668 | if (adapter->wol & E1000_WUFC_EX) |
1669 | wol->wolopts |= WAKE_UCAST; |
1670 | if (adapter->wol & E1000_WUFC_MC) |
1671 | wol->wolopts |= WAKE_MCAST; |
1672 | if (adapter->wol & E1000_WUFC_BC) |
1673 | wol->wolopts |= WAKE_BCAST; |
1674 | if (adapter->wol & E1000_WUFC_MAG) |
1675 | wol->wolopts |= WAKE_MAGIC; |
1676 | } |
1677 | |
1678 | static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) |
1679 | { |
1680 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1681 | struct e1000_hw *hw = &adapter->hw; |
1682 | |
1683 | if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE)) |
1684 | return -EOPNOTSUPP; |
1685 | |
1686 | if (e1000_wol_exclusion(adapter, wol) || |
1687 | !device_can_wakeup(dev: &adapter->pdev->dev)) |
1688 | return wol->wolopts ? -EOPNOTSUPP : 0; |
1689 | |
1690 | switch (hw->device_id) { |
1691 | case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3: |
1692 | if (wol->wolopts & WAKE_UCAST) { |
1693 | e_err(drv, "Interface does not support directed " |
1694 | "(unicast) frame wake-up packets\n" ); |
1695 | return -EOPNOTSUPP; |
1696 | } |
1697 | break; |
1698 | default: |
1699 | break; |
1700 | } |
1701 | |
1702 | /* these settings will always override what we currently have */ |
1703 | adapter->wol = 0; |
1704 | |
1705 | if (wol->wolopts & WAKE_UCAST) |
1706 | adapter->wol |= E1000_WUFC_EX; |
1707 | if (wol->wolopts & WAKE_MCAST) |
1708 | adapter->wol |= E1000_WUFC_MC; |
1709 | if (wol->wolopts & WAKE_BCAST) |
1710 | adapter->wol |= E1000_WUFC_BC; |
1711 | if (wol->wolopts & WAKE_MAGIC) |
1712 | adapter->wol |= E1000_WUFC_MAG; |
1713 | |
1714 | device_set_wakeup_enable(dev: &adapter->pdev->dev, enable: adapter->wol); |
1715 | |
1716 | return 0; |
1717 | } |
1718 | |
1719 | static int e1000_set_phys_id(struct net_device *netdev, |
1720 | enum ethtool_phys_id_state state) |
1721 | { |
1722 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1723 | struct e1000_hw *hw = &adapter->hw; |
1724 | |
1725 | switch (state) { |
1726 | case ETHTOOL_ID_ACTIVE: |
1727 | e1000_setup_led(hw); |
1728 | return 2; |
1729 | |
1730 | case ETHTOOL_ID_ON: |
1731 | e1000_led_on(hw); |
1732 | break; |
1733 | |
1734 | case ETHTOOL_ID_OFF: |
1735 | e1000_led_off(hw); |
1736 | break; |
1737 | |
1738 | case ETHTOOL_ID_INACTIVE: |
1739 | e1000_cleanup_led(hw); |
1740 | } |
1741 | |
1742 | return 0; |
1743 | } |
1744 | |
1745 | static int e1000_get_coalesce(struct net_device *netdev, |
1746 | struct ethtool_coalesce *ec, |
1747 | struct kernel_ethtool_coalesce *kernel_coal, |
1748 | struct netlink_ext_ack *extack) |
1749 | { |
1750 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1751 | |
1752 | if (adapter->hw.mac_type < e1000_82545) |
1753 | return -EOPNOTSUPP; |
1754 | |
1755 | if (adapter->itr_setting <= 4) |
1756 | ec->rx_coalesce_usecs = adapter->itr_setting; |
1757 | else |
1758 | ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting; |
1759 | |
1760 | return 0; |
1761 | } |
1762 | |
1763 | static int e1000_set_coalesce(struct net_device *netdev, |
1764 | struct ethtool_coalesce *ec, |
1765 | struct kernel_ethtool_coalesce *kernel_coal, |
1766 | struct netlink_ext_ack *extack) |
1767 | { |
1768 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1769 | struct e1000_hw *hw = &adapter->hw; |
1770 | |
1771 | if (hw->mac_type < e1000_82545) |
1772 | return -EOPNOTSUPP; |
1773 | |
1774 | if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) || |
1775 | ((ec->rx_coalesce_usecs > 4) && |
1776 | (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) || |
1777 | (ec->rx_coalesce_usecs == 2)) |
1778 | return -EINVAL; |
1779 | |
1780 | if (ec->rx_coalesce_usecs == 4) { |
1781 | adapter->itr = adapter->itr_setting = 4; |
1782 | } else if (ec->rx_coalesce_usecs <= 3) { |
1783 | adapter->itr = 20000; |
1784 | adapter->itr_setting = ec->rx_coalesce_usecs; |
1785 | } else { |
1786 | adapter->itr = (1000000 / ec->rx_coalesce_usecs); |
1787 | adapter->itr_setting = adapter->itr & ~3; |
1788 | } |
1789 | |
1790 | if (adapter->itr_setting != 0) |
1791 | ew32(ITR, 1000000000 / (adapter->itr * 256)); |
1792 | else |
1793 | ew32(ITR, 0); |
1794 | |
1795 | return 0; |
1796 | } |
1797 | |
1798 | static int e1000_nway_reset(struct net_device *netdev) |
1799 | { |
1800 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1801 | |
1802 | if (netif_running(dev: netdev)) |
1803 | e1000_reinit_locked(adapter); |
1804 | return 0; |
1805 | } |
1806 | |
1807 | static void e1000_get_ethtool_stats(struct net_device *netdev, |
1808 | struct ethtool_stats *stats, u64 *data) |
1809 | { |
1810 | struct e1000_adapter *adapter = netdev_priv(dev: netdev); |
1811 | int i; |
1812 | const struct e1000_stats *stat = e1000_gstrings_stats; |
1813 | |
1814 | e1000_update_stats(adapter); |
1815 | for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++, stat++) { |
1816 | char *p; |
1817 | |
1818 | switch (stat->type) { |
1819 | case NETDEV_STATS: |
1820 | p = (char *)netdev + stat->stat_offset; |
1821 | break; |
1822 | case E1000_STATS: |
1823 | p = (char *)adapter + stat->stat_offset; |
1824 | break; |
1825 | default: |
1826 | netdev_WARN_ONCE(netdev, "Invalid E1000 stat type: %u index %d\n" , |
1827 | stat->type, i); |
1828 | continue; |
1829 | } |
1830 | |
1831 | if (stat->sizeof_stat == sizeof(u64)) |
1832 | data[i] = *(u64 *)p; |
1833 | else |
1834 | data[i] = *(u32 *)p; |
1835 | } |
1836 | /* BUG_ON(i != E1000_STATS_LEN); */ |
1837 | } |
1838 | |
1839 | static void e1000_get_strings(struct net_device *netdev, u32 stringset, |
1840 | u8 *data) |
1841 | { |
1842 | u8 *p = data; |
1843 | int i; |
1844 | |
1845 | switch (stringset) { |
1846 | case ETH_SS_TEST: |
1847 | memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test)); |
1848 | break; |
1849 | case ETH_SS_STATS: |
1850 | for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) { |
1851 | memcpy(p, e1000_gstrings_stats[i].stat_string, |
1852 | ETH_GSTRING_LEN); |
1853 | p += ETH_GSTRING_LEN; |
1854 | } |
1855 | /* BUG_ON(p - data != E1000_STATS_LEN * ETH_GSTRING_LEN); */ |
1856 | break; |
1857 | } |
1858 | } |
1859 | |
1860 | static const struct ethtool_ops e1000_ethtool_ops = { |
1861 | .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS, |
1862 | .get_drvinfo = e1000_get_drvinfo, |
1863 | .get_regs_len = e1000_get_regs_len, |
1864 | .get_regs = e1000_get_regs, |
1865 | .get_wol = e1000_get_wol, |
1866 | .set_wol = e1000_set_wol, |
1867 | .get_msglevel = e1000_get_msglevel, |
1868 | .set_msglevel = e1000_set_msglevel, |
1869 | .nway_reset = e1000_nway_reset, |
1870 | .get_link = e1000_get_link, |
1871 | .get_eeprom_len = e1000_get_eeprom_len, |
1872 | .get_eeprom = e1000_get_eeprom, |
1873 | .set_eeprom = e1000_set_eeprom, |
1874 | .get_ringparam = e1000_get_ringparam, |
1875 | .set_ringparam = e1000_set_ringparam, |
1876 | .get_pauseparam = e1000_get_pauseparam, |
1877 | .set_pauseparam = e1000_set_pauseparam, |
1878 | .self_test = e1000_diag_test, |
1879 | .get_strings = e1000_get_strings, |
1880 | .set_phys_id = e1000_set_phys_id, |
1881 | .get_ethtool_stats = e1000_get_ethtool_stats, |
1882 | .get_sset_count = e1000_get_sset_count, |
1883 | .get_coalesce = e1000_get_coalesce, |
1884 | .set_coalesce = e1000_set_coalesce, |
1885 | .get_ts_info = ethtool_op_get_ts_info, |
1886 | .get_link_ksettings = e1000_get_link_ksettings, |
1887 | .set_link_ksettings = e1000_set_link_ksettings, |
1888 | }; |
1889 | |
1890 | void e1000_set_ethtool_ops(struct net_device *netdev) |
1891 | { |
1892 | netdev->ethtool_ops = &e1000_ethtool_ops; |
1893 | } |
1894 | |