1 /******************************************************************************
2 SPDX-License-Identifier: BSD-3-Clause
3
4 Copyright (c) 2001-2020, Intel Corporation
5 All rights reserved.
6
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
9
10 1. Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer.
12
13 2. Redistributions in binary form must reproduce the above copyright
14 notice, this list of conditions and the following disclaimer in the
15 documentation and/or other materials provided with the distribution.
16
17 3. Neither the name of the Intel Corporation nor the names of its
18 contributors may be used to endorse or promote products derived from
19 this software without specific prior written permission.
20
21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 POSSIBILITY OF SUCH DAMAGE.
32
33 ******************************************************************************/
34 /*$FreeBSD$*/
35
36 #include "e1000_api.h"
37
38 static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw);
39 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
40 static void e1000_config_collision_dist_generic(struct e1000_hw *hw);
41
42 /**
43 * e1000_init_mac_ops_generic - Initialize MAC function pointers
44 * @hw: pointer to the HW structure
45 *
46 * Setups up the function pointers to no-op functions
47 **/
48 void e1000_init_mac_ops_generic(struct e1000_hw *hw)
49 {
50 struct e1000_mac_info *mac = &hw->mac;
51 DEBUGFUNC("e1000_init_mac_ops_generic");
52
53 /* General Setup */
54 mac->ops.init_params = e1000_null_ops_generic;
55 mac->ops.init_hw = e1000_null_ops_generic;
56 mac->ops.reset_hw = e1000_null_ops_generic;
57 mac->ops.setup_physical_interface = e1000_null_ops_generic;
58 mac->ops.get_bus_info = e1000_null_ops_generic;
59 mac->ops.set_lan_id = e1000_set_lan_id_multi_port_pcie;
60 mac->ops.read_mac_addr = e1000_read_mac_addr_generic;
61 mac->ops.config_collision_dist = e1000_config_collision_dist_generic;
62 mac->ops.clear_hw_cntrs = e1000_null_mac_generic;
63 /* LED */
64 mac->ops.cleanup_led = e1000_null_ops_generic;
65 mac->ops.setup_led = e1000_null_ops_generic;
66 mac->ops.blink_led = e1000_null_ops_generic;
67 mac->ops.led_on = e1000_null_ops_generic;
68 mac->ops.led_off = e1000_null_ops_generic;
69 /* LINK */
70 mac->ops.setup_link = e1000_null_ops_generic;
71 mac->ops.get_link_up_info = e1000_null_link_info;
72 mac->ops.check_for_link = e1000_null_ops_generic;
73 mac->ops.set_obff_timer = e1000_null_set_obff_timer;
74 /* Management */
75 mac->ops.check_mng_mode = e1000_null_mng_mode;
76 /* VLAN, MC, etc. */
77 mac->ops.update_mc_addr_list = e1000_null_update_mc;
78 mac->ops.clear_vfta = e1000_null_mac_generic;
79 mac->ops.write_vfta = e1000_null_write_vfta;
80 mac->ops.rar_set = e1000_rar_set_generic;
81 mac->ops.validate_mdi_setting = e1000_validate_mdi_setting_generic;
82 }
83
84 /**
85 * e1000_null_ops_generic - No-op function, returns 0
86 * @hw: pointer to the HW structure
87 **/
88 s32 e1000_null_ops_generic(struct e1000_hw E1000_UNUSEDARG *hw)
89 {
90 DEBUGFUNC("e1000_null_ops_generic");
91 return E1000_SUCCESS;
92 }
93
94 /**
95 * e1000_null_mac_generic - No-op function, return void
96 * @hw: pointer to the HW structure
97 **/
98 void e1000_null_mac_generic(struct e1000_hw E1000_UNUSEDARG *hw)
99 {
100 DEBUGFUNC("e1000_null_mac_generic");
101 return;
102 }
103
104 /**
105 * e1000_null_link_info - No-op function, return 0
106 * @hw: pointer to the HW structure
107 * @s: dummy variable
108 * @d: dummy variable
109 **/
110 s32 e1000_null_link_info(struct e1000_hw E1000_UNUSEDARG *hw,
111 u16 E1000_UNUSEDARG *s, u16 E1000_UNUSEDARG *d)
112 {
113 DEBUGFUNC("e1000_null_link_info");
114 return E1000_SUCCESS;
115 }
116
117 /**
118 * e1000_null_mng_mode - No-op function, return false
119 * @hw: pointer to the HW structure
120 **/
121 bool e1000_null_mng_mode(struct e1000_hw E1000_UNUSEDARG *hw)
122 {
123 DEBUGFUNC("e1000_null_mng_mode");
124 return false;
125 }
126
127 /**
128 * e1000_null_update_mc - No-op function, return void
129 * @hw: pointer to the HW structure
130 * @h: dummy variable
131 * @a: dummy variable
132 **/
133 void e1000_null_update_mc(struct e1000_hw E1000_UNUSEDARG *hw,
134 u8 E1000_UNUSEDARG *h, u32 E1000_UNUSEDARG a)
135 {
136 DEBUGFUNC("e1000_null_update_mc");
137 return;
138 }
139
140 /**
141 * e1000_null_write_vfta - No-op function, return void
142 * @hw: pointer to the HW structure
143 * @a: dummy variable
144 * @b: dummy variable
145 **/
146 void e1000_null_write_vfta(struct e1000_hw E1000_UNUSEDARG *hw,
147 u32 E1000_UNUSEDARG a, u32 E1000_UNUSEDARG b)
148 {
149 DEBUGFUNC("e1000_null_write_vfta");
150 return;
151 }
152
153 /**
154 * e1000_null_rar_set - No-op function, return 0
155 * @hw: pointer to the HW structure
156 * @h: dummy variable
157 * @a: dummy variable
158 **/
159 int e1000_null_rar_set(struct e1000_hw E1000_UNUSEDARG *hw,
160 u8 E1000_UNUSEDARG *h, u32 E1000_UNUSEDARG a)
161 {
162 DEBUGFUNC("e1000_null_rar_set");
163 return E1000_SUCCESS;
164 }
165
166 /**
167 * e1000_null_set_obff_timer - No-op function, return 0
168 * @hw: pointer to the HW structure
169 **/
170 s32 e1000_null_set_obff_timer(struct e1000_hw E1000_UNUSEDARG *hw,
171 u32 E1000_UNUSEDARG a)
172 {
173 DEBUGFUNC("e1000_null_set_obff_timer");
174 return E1000_SUCCESS;
175 }
176
177 /**
178 * e1000_get_bus_info_pci_generic - Get PCI(x) bus information
179 * @hw: pointer to the HW structure
180 *
181 * Determines and stores the system bus information for a particular
182 * network interface. The following bus information is determined and stored:
183 * bus speed, bus width, type (PCI/PCIx), and PCI(-x) function.
184 **/
185 s32 e1000_get_bus_info_pci_generic(struct e1000_hw *hw)
186 {
187 struct e1000_mac_info *mac = &hw->mac;
188 struct e1000_bus_info *bus = &hw->bus;
189 u32 status = E1000_READ_REG(hw, E1000_STATUS);
190 s32 ret_val = E1000_SUCCESS;
191
192 DEBUGFUNC("e1000_get_bus_info_pci_generic");
193
194 /* PCI or PCI-X? */
195 bus->type = (status & E1000_STATUS_PCIX_MODE)
196 ? e1000_bus_type_pcix
197 : e1000_bus_type_pci;
198
199 /* Bus speed */
200 if (bus->type == e1000_bus_type_pci) {
201 bus->speed = (status & E1000_STATUS_PCI66)
202 ? e1000_bus_speed_66
203 : e1000_bus_speed_33;
204 } else {
205 switch (status & E1000_STATUS_PCIX_SPEED) {
206 case E1000_STATUS_PCIX_SPEED_66:
207 bus->speed = e1000_bus_speed_66;
208 break;
209 case E1000_STATUS_PCIX_SPEED_100:
210 bus->speed = e1000_bus_speed_100;
211 break;
212 case E1000_STATUS_PCIX_SPEED_133:
213 bus->speed = e1000_bus_speed_133;
214 break;
215 default:
216 bus->speed = e1000_bus_speed_reserved;
217 break;
218 }
219 }
220
221 /* Bus width */
222 bus->width = (status & E1000_STATUS_BUS64)
223 ? e1000_bus_width_64
224 : e1000_bus_width_32;
225
226 /* Which PCI(-X) function? */
227 mac->ops.set_lan_id(hw);
228
229 return ret_val;
230 }
231
232 /**
233 * e1000_get_bus_info_pcie_generic - Get PCIe bus information
234 * @hw: pointer to the HW structure
235 *
236 * Determines and stores the system bus information for a particular
237 * network interface. The following bus information is determined and stored:
238 * bus speed, bus width, type (PCIe), and PCIe function.
239 **/
240 s32 e1000_get_bus_info_pcie_generic(struct e1000_hw *hw)
241 {
242 struct e1000_mac_info *mac = &hw->mac;
243 struct e1000_bus_info *bus = &hw->bus;
244 s32 ret_val;
245 u16 pcie_link_status;
246
247 DEBUGFUNC("e1000_get_bus_info_pcie_generic");
248
249 bus->type = e1000_bus_type_pci_express;
250
251 ret_val = e1000_read_pcie_cap_reg(hw, PCIE_LINK_STATUS,
252 &pcie_link_status);
253 if (ret_val) {
254 bus->width = e1000_bus_width_unknown;
255 bus->speed = e1000_bus_speed_unknown;
256 } else {
257 switch (pcie_link_status & PCIE_LINK_SPEED_MASK) {
258 case PCIE_LINK_SPEED_2500:
259 bus->speed = e1000_bus_speed_2500;
260 break;
261 case PCIE_LINK_SPEED_5000:
262 bus->speed = e1000_bus_speed_5000;
263 break;
264 default:
265 bus->speed = e1000_bus_speed_unknown;
266 break;
267 }
268
269 bus->width = (enum e1000_bus_width)((pcie_link_status &
270 PCIE_LINK_WIDTH_MASK) >> PCIE_LINK_WIDTH_SHIFT);
271 }
272
273 mac->ops.set_lan_id(hw);
274
275 return E1000_SUCCESS;
276 }
277
278 /**
279 * e1000_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices
280 *
281 * @hw: pointer to the HW structure
282 *
283 * Determines the LAN function id by reading memory-mapped registers
284 * and swaps the port value if requested.
285 **/
286 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw)
287 {
288 struct e1000_bus_info *bus = &hw->bus;
289 u32 reg;
290
291 /* The status register reports the correct function number
292 * for the device regardless of function swap state.
293 */
294 reg = E1000_READ_REG(hw, E1000_STATUS);
295 bus->func = (reg & E1000_STATUS_FUNC_MASK) >> E1000_STATUS_FUNC_SHIFT;
296 }
297
298 /**
299 * e1000_set_lan_id_multi_port_pci - Set LAN id for PCI multiple port devices
300 * @hw: pointer to the HW structure
301 *
302 * Determines the LAN function id by reading PCI config space.
303 **/
304 void e1000_set_lan_id_multi_port_pci(struct e1000_hw *hw)
305 {
306 struct e1000_bus_info *bus = &hw->bus;
307 u16 pci_header_type;
308 u32 status;
309
310 e1000_read_pci_cfg(hw, PCI_HEADER_TYPE_REGISTER, &pci_header_type);
311 if (pci_header_type & PCI_HEADER_TYPE_MULTIFUNC) {
312 status = E1000_READ_REG(hw, E1000_STATUS);
313 bus->func = (status & E1000_STATUS_FUNC_MASK)
314 >> E1000_STATUS_FUNC_SHIFT;
315 } else {
316 bus->func = 0;
317 }
318 }
319
320 /**
321 * e1000_set_lan_id_single_port - Set LAN id for a single port device
322 * @hw: pointer to the HW structure
323 *
324 * Sets the LAN function id to zero for a single port device.
325 **/
326 void e1000_set_lan_id_single_port(struct e1000_hw *hw)
327 {
328 struct e1000_bus_info *bus = &hw->bus;
329
330 bus->func = 0;
331 }
332
333 /**
334 * e1000_clear_vfta_generic - Clear VLAN filter table
335 * @hw: pointer to the HW structure
336 *
337 * Clears the register array which contains the VLAN filter table by
338 * setting all the values to 0.
339 **/
340 void e1000_clear_vfta_generic(struct e1000_hw *hw)
341 {
342 u32 offset;
343
344 DEBUGFUNC("e1000_clear_vfta_generic");
345
346 for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
347 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0);
348 E1000_WRITE_FLUSH(hw);
349 }
350 }
351
352 /**
353 * e1000_write_vfta_generic - Write value to VLAN filter table
354 * @hw: pointer to the HW structure
355 * @offset: register offset in VLAN filter table
356 * @value: register value written to VLAN filter table
357 *
358 * Writes value at the given offset in the register array which stores
359 * the VLAN filter table.
360 **/
361 void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value)
362 {
363 DEBUGFUNC("e1000_write_vfta_generic");
364
365 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
366 E1000_WRITE_FLUSH(hw);
367 }
368
369 /**
370 * e1000_init_rx_addrs_generic - Initialize receive address's
371 * @hw: pointer to the HW structure
372 * @rar_count: receive address registers
373 *
374 * Setup the receive address registers by setting the base receive address
375 * register to the devices MAC address and clearing all the other receive
376 * address registers to 0.
377 **/
378 void e1000_init_rx_addrs_generic(struct e1000_hw *hw, u16 rar_count)
379 {
380 u32 i;
381 u8 mac_addr[ETHER_ADDR_LEN] = {0};
382
383 DEBUGFUNC("e1000_init_rx_addrs_generic");
384
385 /* Setup the receive address */
386 DEBUGOUT("Programming MAC Address into RAR[0]\n");
387
388 hw->mac.ops.rar_set(hw, hw->mac.addr, 0);
389
390 /* Zero out the other (rar_entry_count - 1) receive addresses */
391 DEBUGOUT1("Clearing RAR[1-%u]\n", rar_count-1);
392 for (i = 1; i < rar_count; i++)
393 hw->mac.ops.rar_set(hw, mac_addr, i);
394 }
395
396 /**
397 * e1000_check_alt_mac_addr_generic - Check for alternate MAC addr
398 * @hw: pointer to the HW structure
399 *
400 * Checks the nvm for an alternate MAC address. An alternate MAC address
401 * can be setup by pre-boot software and must be treated like a permanent
402 * address and must override the actual permanent MAC address. If an
403 * alternate MAC address is found it is programmed into RAR0, replacing
404 * the permanent address that was installed into RAR0 by the Si on reset.
405 * This function will return SUCCESS unless it encounters an error while
406 * reading the EEPROM.
407 **/
408 s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
409 {
410 u32 i;
411 s32 ret_val;
412 u16 offset, nvm_alt_mac_addr_offset, nvm_data;
413 u8 alt_mac_addr[ETHER_ADDR_LEN];
414
415 DEBUGFUNC("e1000_check_alt_mac_addr_generic");
416
417 ret_val = hw->nvm.ops.read(hw, NVM_COMPAT, 1, &nvm_data);
418 if (ret_val)
419 return ret_val;
420
421 /* not supported on older hardware or 82573 */
422 if ((hw->mac.type < e1000_82571) || (hw->mac.type == e1000_82573))
423 return E1000_SUCCESS;
424
425 /* Alternate MAC address is handled by the option ROM for 82580
426 * and newer. SW support not required.
427 */
428 if (hw->mac.type >= e1000_82580)
429 return E1000_SUCCESS;
430
431 ret_val = hw->nvm.ops.read(hw, NVM_ALT_MAC_ADDR_PTR, 1,
432 &nvm_alt_mac_addr_offset);
433 if (ret_val) {
434 DEBUGOUT("NVM Read Error\n");
435 return ret_val;
436 }
437
438 if ((nvm_alt_mac_addr_offset == 0xFFFF) ||
439 (nvm_alt_mac_addr_offset == 0x0000))
440 /* There is no Alternate MAC Address */
441 return E1000_SUCCESS;
442
443 if (hw->bus.func == E1000_FUNC_1)
444 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1;
445 if (hw->bus.func == E1000_FUNC_2)
446 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN2;
447
448 if (hw->bus.func == E1000_FUNC_3)
449 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN3;
450 for (i = 0; i < ETHER_ADDR_LEN; i += 2) {
451 offset = nvm_alt_mac_addr_offset + (i >> 1);
452 ret_val = hw->nvm.ops.read(hw, offset, 1, &nvm_data);
453 if (ret_val) {
454 DEBUGOUT("NVM Read Error\n");
455 return ret_val;
456 }
457
458 alt_mac_addr[i] = (u8)(nvm_data & 0xFF);
459 alt_mac_addr[i + 1] = (u8)(nvm_data >> 8);
460 }
461
462 /* if multicast bit is set, the alternate address will not be used */
463 if (alt_mac_addr[0] & 0x01) {
464 DEBUGOUT("Ignoring Alternate Mac Address with MC bit set\n");
465 return E1000_SUCCESS;
466 }
467
468 /* We have a valid alternate MAC address, and we want to treat it the
469 * same as the normal permanent MAC address stored by the HW into the
470 * RAR. Do this by mapping this address into RAR0.
471 */
472 hw->mac.ops.rar_set(hw, alt_mac_addr, 0);
473
474 return E1000_SUCCESS;
475 }
476
477 /**
478 * e1000_rar_set_generic - Set receive address register
479 * @hw: pointer to the HW structure
480 * @addr: pointer to the receive address
481 * @index: receive address array register
482 *
483 * Sets the receive address array register at index to the address passed
484 * in by addr.
485 **/
486 int e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
487 {
488 u32 rar_low, rar_high;
489
490 DEBUGFUNC("e1000_rar_set_generic");
491
492 /* HW expects these in little endian so we reverse the byte order
493 * from network order (big endian) to little endian
494 */
495 rar_low = ((u32) addr[0] | ((u32) addr[1] << 8) |
496 ((u32) addr[2] << 16) | ((u32) addr[3] << 24));
497
498 rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
499
500 /* If MAC address zero, no need to set the AV bit */
501 if (rar_low || rar_high)
502 rar_high |= E1000_RAH_AV;
503
504 /* Some bridges will combine consecutive 32-bit writes into
505 * a single burst write, which will malfunction on some parts.
506 * The flushes avoid this.
507 */
508 E1000_WRITE_REG(hw, E1000_RAL(index), rar_low);
509 E1000_WRITE_FLUSH(hw);
510 E1000_WRITE_REG(hw, E1000_RAH(index), rar_high);
511 E1000_WRITE_FLUSH(hw);
512
513 return E1000_SUCCESS;
514 }
515
516 /**
517 * e1000_hash_mc_addr_generic - Generate a multicast hash value
518 * @hw: pointer to the HW structure
519 * @mc_addr: pointer to a multicast address
520 *
521 * Generates a multicast address hash value which is used to determine
522 * the multicast filter table array address and new table value.
523 **/
524 u32 e1000_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr)
525 {
526 u32 hash_value, hash_mask;
527 u8 bit_shift = 0;
528
529 DEBUGFUNC("e1000_hash_mc_addr_generic");
530
531 /* Register count multiplied by bits per register */
532 hash_mask = (hw->mac.mta_reg_count * 32) - 1;
533
534 /* For a mc_filter_type of 0, bit_shift is the number of left-shifts
535 * where 0xFF would still fall within the hash mask.
536 */
537 while (hash_mask >> bit_shift != 0xFF)
538 bit_shift++;
539
540 /* The portion of the address that is used for the hash table
541 * is determined by the mc_filter_type setting.
542 * The algorithm is such that there is a total of 8 bits of shifting.
543 * The bit_shift for a mc_filter_type of 0 represents the number of
544 * left-shifts where the MSB of mc_addr[5] would still fall within
545 * the hash_mask. Case 0 does this exactly. Since there are a total
546 * of 8 bits of shifting, then mc_addr[4] will shift right the
547 * remaining number of bits. Thus 8 - bit_shift. The rest of the
548 * cases are a variation of this algorithm...essentially raising the
549 * number of bits to shift mc_addr[5] left, while still keeping the
550 * 8-bit shifting total.
551 *
552 * For example, given the following Destination MAC Address and an
553 * mta register count of 128 (thus a 4096-bit vector and 0xFFF mask),
554 * we can see that the bit_shift for case 0 is 4. These are the hash
555 * values resulting from each mc_filter_type...
556 * [0] [1] [2] [3] [4] [5]
557 * 01 AA 00 12 34 56
558 * LSB MSB
559 *
560 * case 0: hash_value = ((0x34 >> 4) | (0x56 << 4)) & 0xFFF = 0x563
561 * case 1: hash_value = ((0x34 >> 3) | (0x56 << 5)) & 0xFFF = 0xAC6
562 * case 2: hash_value = ((0x34 >> 2) | (0x56 << 6)) & 0xFFF = 0x163
563 * case 3: hash_value = ((0x34 >> 0) | (0x56 << 8)) & 0xFFF = 0x634
564 */
565 switch (hw->mac.mc_filter_type) {
566 default:
567 case 0:
568 break;
569 case 1:
570 bit_shift += 1;
571 break;
572 case 2:
573 bit_shift += 2;
574 break;
575 case 3:
576 bit_shift += 4;
577 break;
578 }
579
580 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
581 (((u16) mc_addr[5]) << bit_shift)));
582
583 return hash_value;
584 }
585
586 /**
587 * e1000_update_mc_addr_list_generic - Update Multicast addresses
588 * @hw: pointer to the HW structure
589 * @mc_addr_list: array of multicast addresses to program
590 * @mc_addr_count: number of multicast addresses to program
591 *
592 * Updates entire Multicast Table Array.
593 * The caller must have a packed mc_addr_list of multicast addresses.
594 **/
595 void e1000_update_mc_addr_list_generic(struct e1000_hw *hw,
596 u8 *mc_addr_list, u32 mc_addr_count)
597 {
598 u32 hash_value, hash_bit, hash_reg;
599 int i;
600
601 DEBUGFUNC("e1000_update_mc_addr_list_generic");
602
603 /* clear mta_shadow */
604 memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
605
606 /* update mta_shadow from mc_addr_list */
607 for (i = 0; (u32) i < mc_addr_count; i++) {
608 hash_value = e1000_hash_mc_addr_generic(hw, mc_addr_list);
609
610 hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
611 hash_bit = hash_value & 0x1F;
612
613 hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit);
614 mc_addr_list += (ETHER_ADDR_LEN);
615 }
616
617 /* replace the entire MTA table */
618 for (i = hw->mac.mta_reg_count - 1; i >= 0; i--)
619 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, hw->mac.mta_shadow[i]);
620 E1000_WRITE_FLUSH(hw);
621 }
622
623 /**
624 * e1000_pcix_mmrbc_workaround_generic - Fix incorrect MMRBC value
625 * @hw: pointer to the HW structure
626 *
627 * In certain situations, a system BIOS may report that the PCIx maximum
628 * memory read byte count (MMRBC) value is higher than than the actual
629 * value. We check the PCIx command register with the current PCIx status
630 * register.
631 **/
632 void e1000_pcix_mmrbc_workaround_generic(struct e1000_hw *hw)
633 {
634 u16 cmd_mmrbc;
635 u16 pcix_cmd;
636 u16 pcix_stat_hi_word;
637 u16 stat_mmrbc;
638
639 DEBUGFUNC("e1000_pcix_mmrbc_workaround_generic");
640
641 /* Workaround for PCI-X issue when BIOS sets MMRBC incorrectly */
642 if (hw->bus.type != e1000_bus_type_pcix)
643 return;
644
645 e1000_read_pci_cfg(hw, PCIX_COMMAND_REGISTER, &pcix_cmd);
646 e1000_read_pci_cfg(hw, PCIX_STATUS_REGISTER_HI, &pcix_stat_hi_word);
647 cmd_mmrbc = (pcix_cmd & PCIX_COMMAND_MMRBC_MASK) >>
648 PCIX_COMMAND_MMRBC_SHIFT;
649 stat_mmrbc = (pcix_stat_hi_word & PCIX_STATUS_HI_MMRBC_MASK) >>
650 PCIX_STATUS_HI_MMRBC_SHIFT;
651 if (stat_mmrbc == PCIX_STATUS_HI_MMRBC_4K)
652 stat_mmrbc = PCIX_STATUS_HI_MMRBC_2K;
653 if (cmd_mmrbc > stat_mmrbc) {
654 pcix_cmd &= ~PCIX_COMMAND_MMRBC_MASK;
655 pcix_cmd |= stat_mmrbc << PCIX_COMMAND_MMRBC_SHIFT;
656 e1000_write_pci_cfg(hw, PCIX_COMMAND_REGISTER, &pcix_cmd);
657 }
658 }
659
660 /**
661 * e1000_clear_hw_cntrs_base_generic - Clear base hardware counters
662 * @hw: pointer to the HW structure
663 *
664 * Clears the base hardware counters by reading the counter registers.
665 **/
666 void e1000_clear_hw_cntrs_base_generic(struct e1000_hw *hw)
667 {
668 DEBUGFUNC("e1000_clear_hw_cntrs_base_generic");
669
670 E1000_READ_REG(hw, E1000_CRCERRS);
671 E1000_READ_REG(hw, E1000_SYMERRS);
672 E1000_READ_REG(hw, E1000_MPC);
673 E1000_READ_REG(hw, E1000_SCC);
674 E1000_READ_REG(hw, E1000_ECOL);
675 E1000_READ_REG(hw, E1000_MCC);
676 E1000_READ_REG(hw, E1000_LATECOL);
677 E1000_READ_REG(hw, E1000_COLC);
678 E1000_READ_REG(hw, E1000_DC);
679 E1000_READ_REG(hw, E1000_SEC);
680 E1000_READ_REG(hw, E1000_RLEC);
681 E1000_READ_REG(hw, E1000_XONRXC);
682 E1000_READ_REG(hw, E1000_XONTXC);
683 E1000_READ_REG(hw, E1000_XOFFRXC);
684 E1000_READ_REG(hw, E1000_XOFFTXC);
685 E1000_READ_REG(hw, E1000_FCRUC);
686 E1000_READ_REG(hw, E1000_GPRC);
687 E1000_READ_REG(hw, E1000_BPRC);
688 E1000_READ_REG(hw, E1000_MPRC);
689 E1000_READ_REG(hw, E1000_GPTC);
690 E1000_READ_REG(hw, E1000_GORCL);
691 E1000_READ_REG(hw, E1000_GORCH);
692 E1000_READ_REG(hw, E1000_GOTCL);
693 E1000_READ_REG(hw, E1000_GOTCH);
694 E1000_READ_REG(hw, E1000_RNBC);
695 E1000_READ_REG(hw, E1000_RUC);
696 E1000_READ_REG(hw, E1000_RFC);
697 E1000_READ_REG(hw, E1000_ROC);
698 E1000_READ_REG(hw, E1000_RJC);
699 E1000_READ_REG(hw, E1000_TORL);
700 E1000_READ_REG(hw, E1000_TORH);
701 E1000_READ_REG(hw, E1000_TOTL);
702 E1000_READ_REG(hw, E1000_TOTH);
703 E1000_READ_REG(hw, E1000_TPR);
704 E1000_READ_REG(hw, E1000_TPT);
705 E1000_READ_REG(hw, E1000_MPTC);
706 E1000_READ_REG(hw, E1000_BPTC);
707 }
708
709 /**
710 * e1000_check_for_copper_link_generic - Check for link (Copper)
711 * @hw: pointer to the HW structure
712 *
713 * Checks to see of the link status of the hardware has changed. If a
714 * change in link status has been detected, then we read the PHY registers
715 * to get the current speed/duplex if link exists.
716 **/
717 s32 e1000_check_for_copper_link_generic(struct e1000_hw *hw)
718 {
719 struct e1000_mac_info *mac = &hw->mac;
720 s32 ret_val;
721 bool link;
722
723 DEBUGFUNC("e1000_check_for_copper_link");
724
725 /* We only want to go out to the PHY registers to see if Auto-Neg
726 * has completed and/or if our link status has changed. The
727 * get_link_status flag is set upon receiving a Link Status
728 * Change or Rx Sequence Error interrupt.
729 */
730 if (!mac->get_link_status)
731 return E1000_SUCCESS;
732
733 /* First we want to see if the MII Status Register reports
734 * link. If so, then we want to get the current speed/duplex
735 * of the PHY.
736 */
737 ret_val = e1000_phy_has_link_generic(hw, 1, 0, &link);
738 if (ret_val)
739 return ret_val;
740
741 if (!link)
742 return E1000_SUCCESS; /* No link detected */
743
744 mac->get_link_status = false;
745
746 /* Check if there was DownShift, must be checked
747 * immediately after link-up
748 */
749 e1000_check_downshift_generic(hw);
750
751 /* If we are forcing speed/duplex, then we simply return since
752 * we have already determined whether we have link or not.
753 */
754 if (!mac->autoneg)
755 return -E1000_ERR_CONFIG;
756
757 /* Auto-Neg is enabled. Auto Speed Detection takes care
758 * of MAC speed/duplex configuration. So we only need to
759 * configure Collision Distance in the MAC.
760 */
761 mac->ops.config_collision_dist(hw);
762
763 /* Configure Flow Control now that Auto-Neg has completed.
764 * First, we need to restore the desired flow control
765 * settings because we may have had to re-autoneg with a
766 * different link partner.
767 */
768 ret_val = e1000_config_fc_after_link_up_generic(hw);
769 if (ret_val)
770 DEBUGOUT("Error configuring flow control\n");
771
772 return ret_val;
773 }
774
775 /**
776 * e1000_check_for_fiber_link_generic - Check for link (Fiber)
777 * @hw: pointer to the HW structure
778 *
779 * Checks for link up on the hardware. If link is not up and we have
780 * a signal, then we need to force link up.
781 **/
782 s32 e1000_check_for_fiber_link_generic(struct e1000_hw *hw)
783 {
784 struct e1000_mac_info *mac = &hw->mac;
785 u32 rxcw;
786 u32 ctrl;
787 u32 status;
788 s32 ret_val;
789
790 DEBUGFUNC("e1000_check_for_fiber_link_generic");
791
792 ctrl = E1000_READ_REG(hw, E1000_CTRL);
793 status = E1000_READ_REG(hw, E1000_STATUS);
794 rxcw = E1000_READ_REG(hw, E1000_RXCW);
795
796 /* If we don't have link (auto-negotiation failed or link partner
797 * cannot auto-negotiate), the cable is plugged in (we have signal),
798 * and our link partner is not trying to auto-negotiate with us (we
799 * are receiving idles or data), we need to force link up. We also
800 * need to give auto-negotiation time to complete, in case the cable
801 * was just plugged in. The autoneg_failed flag does this.
802 */
803 /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
804 if ((ctrl & E1000_CTRL_SWDPIN1) && !(status & E1000_STATUS_LU) &&
805 !(rxcw & E1000_RXCW_C)) {
806 if (!mac->autoneg_failed) {
807 mac->autoneg_failed = true;
808 return E1000_SUCCESS;
809 }
810 DEBUGOUT("NOT Rx'ing /C/, disable AutoNeg and force link.\n");
811
812 /* Disable auto-negotiation in the TXCW register */
813 E1000_WRITE_REG(hw, E1000_TXCW, (mac->txcw & ~E1000_TXCW_ANE));
814
815 /* Force link-up and also force full-duplex. */
816 ctrl = E1000_READ_REG(hw, E1000_CTRL);
817 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
818 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
819
820 /* Configure Flow Control after forcing link up. */
821 ret_val = e1000_config_fc_after_link_up_generic(hw);
822 if (ret_val) {
823 DEBUGOUT("Error configuring flow control\n");
824 return ret_val;
825 }
826 } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
827 /* If we are forcing link and we are receiving /C/ ordered
828 * sets, re-enable auto-negotiation in the TXCW register
829 * and disable forced link in the Device Control register
830 * in an attempt to auto-negotiate with our link partner.
831 */
832 DEBUGOUT("Rx'ing /C/, enable AutoNeg and stop forcing link.\n");
833 E1000_WRITE_REG(hw, E1000_TXCW, mac->txcw);
834 E1000_WRITE_REG(hw, E1000_CTRL, (ctrl & ~E1000_CTRL_SLU));
835
836 mac->serdes_has_link = true;
837 }
838
839 return E1000_SUCCESS;
840 }
841
842 /**
843 * e1000_check_for_serdes_link_generic - Check for link (Serdes)
844 * @hw: pointer to the HW structure
845 *
846 * Checks for link up on the hardware. If link is not up and we have
847 * a signal, then we need to force link up.
848 **/
849 s32 e1000_check_for_serdes_link_generic(struct e1000_hw *hw)
850 {
851 struct e1000_mac_info *mac = &hw->mac;
852 u32 rxcw;
853 u32 ctrl;
854 u32 status;
855 s32 ret_val;
856
857 DEBUGFUNC("e1000_check_for_serdes_link_generic");
858
859 ctrl = E1000_READ_REG(hw, E1000_CTRL);
860 status = E1000_READ_REG(hw, E1000_STATUS);
861 rxcw = E1000_READ_REG(hw, E1000_RXCW);
862
863 /* If we don't have link (auto-negotiation failed or link partner
864 * cannot auto-negotiate), and our link partner is not trying to
865 * auto-negotiate with us (we are receiving idles or data),
866 * we need to force link up. We also need to give auto-negotiation
867 * time to complete.
868 */
869 /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
870 if (!(status & E1000_STATUS_LU) && !(rxcw & E1000_RXCW_C)) {
871 if (!mac->autoneg_failed) {
872 mac->autoneg_failed = true;
873 return E1000_SUCCESS;
874 }
875 DEBUGOUT("NOT Rx'ing /C/, disable AutoNeg and force link.\n");
876
877 /* Disable auto-negotiation in the TXCW register */
878 E1000_WRITE_REG(hw, E1000_TXCW, (mac->txcw & ~E1000_TXCW_ANE));
879
880 /* Force link-up and also force full-duplex. */
881 ctrl = E1000_READ_REG(hw, E1000_CTRL);
882 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
883 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
884
885 /* Configure Flow Control after forcing link up. */
886 ret_val = e1000_config_fc_after_link_up_generic(hw);
887 if (ret_val) {
888 DEBUGOUT("Error configuring flow control\n");
889 return ret_val;
890 }
891 } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
892 /* If we are forcing link and we are receiving /C/ ordered
893 * sets, re-enable auto-negotiation in the TXCW register
894 * and disable forced link in the Device Control register
895 * in an attempt to auto-negotiate with our link partner.
896 */
897 DEBUGOUT("Rx'ing /C/, enable AutoNeg and stop forcing link.\n");
898 E1000_WRITE_REG(hw, E1000_TXCW, mac->txcw);
899 E1000_WRITE_REG(hw, E1000_CTRL, (ctrl & ~E1000_CTRL_SLU));
900
901 mac->serdes_has_link = true;
902 } else if (!(E1000_TXCW_ANE & E1000_READ_REG(hw, E1000_TXCW))) {
903 /* If we force link for non-auto-negotiation switch, check
904 * link status based on MAC synchronization for internal
905 * serdes media type.
906 */
907 /* SYNCH bit and IV bit are sticky. */
908 usec_delay(10);
909 rxcw = E1000_READ_REG(hw, E1000_RXCW);
910 if (rxcw & E1000_RXCW_SYNCH) {
911 if (!(rxcw & E1000_RXCW_IV)) {
912 mac->serdes_has_link = true;
913 DEBUGOUT("SERDES: Link up - forced.\n");
914 }
915 } else {
916 mac->serdes_has_link = false;
917 DEBUGOUT("SERDES: Link down - force failed.\n");
918 }
919 }
920
921 if (E1000_TXCW_ANE & E1000_READ_REG(hw, E1000_TXCW)) {
922 status = E1000_READ_REG(hw, E1000_STATUS);
923 if (status & E1000_STATUS_LU) {
924 /* SYNCH bit and IV bit are sticky, so reread rxcw. */
925 usec_delay(10);
926 rxcw = E1000_READ_REG(hw, E1000_RXCW);
927 if (rxcw & E1000_RXCW_SYNCH) {
928 if (!(rxcw & E1000_RXCW_IV)) {
929 mac->serdes_has_link = true;
930 DEBUGOUT("SERDES: Link up - autoneg completed successfully.\n");
931 } else {
932 mac->serdes_has_link = false;
933 DEBUGOUT("SERDES: Link down - invalid codewords detected in autoneg.\n");
934 }
935 } else {
936 mac->serdes_has_link = false;
937 DEBUGOUT("SERDES: Link down - no sync.\n");
938 }
939 } else {
940 mac->serdes_has_link = false;
941 DEBUGOUT("SERDES: Link down - autoneg failed\n");
942 }
943 }
944
945 return E1000_SUCCESS;
946 }
947
948 /**
949 * e1000_set_default_fc_generic - Set flow control default values
950 * @hw: pointer to the HW structure
951 *
952 * Read the EEPROM for the default values for flow control and store the
953 * values.
954 **/
955 s32 e1000_set_default_fc_generic(struct e1000_hw *hw)
956 {
957 s32 ret_val;
958 u16 nvm_data;
959 u16 nvm_offset = 0;
960
961 DEBUGFUNC("e1000_set_default_fc_generic");
962
963 /* Read and store word 0x0F of the EEPROM. This word contains bits
964 * that determine the hardware's default PAUSE (flow control) mode,
965 * a bit that determines whether the HW defaults to enabling or
966 * disabling auto-negotiation, and the direction of the
967 * SW defined pins. If there is no SW over-ride of the flow
968 * control setting, then the variable hw->fc will
969 * be initialized based on a value in the EEPROM.
970 */
971 if (hw->mac.type == e1000_i350) {
972 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(hw->bus.func);
973 ret_val = hw->nvm.ops.read(hw,
974 NVM_INIT_CONTROL2_REG +
975 nvm_offset,
976 1, &nvm_data);
977 } else {
978 ret_val = hw->nvm.ops.read(hw,
979 NVM_INIT_CONTROL2_REG,
980 1, &nvm_data);
981 }
982
983
984 if (ret_val) {
985 DEBUGOUT("NVM Read Error\n");
986 return ret_val;
987 }
988
989 if (!(nvm_data & NVM_WORD0F_PAUSE_MASK))
990 hw->fc.requested_mode = e1000_fc_none;
991 else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) ==
992 NVM_WORD0F_ASM_DIR)
993 hw->fc.requested_mode = e1000_fc_tx_pause;
994 else
995 hw->fc.requested_mode = e1000_fc_full;
996
997 return E1000_SUCCESS;
998 }
999
1000 /**
1001 * e1000_setup_link_generic - Setup flow control and link settings
1002 * @hw: pointer to the HW structure
1003 *
1004 * Determines which flow control settings to use, then configures flow
1005 * control. Calls the appropriate media-specific link configuration
1006 * function. Assuming the adapter has a valid link partner, a valid link
1007 * should be established. Assumes the hardware has previously been reset
1008 * and the transmitter and receiver are not enabled.
1009 **/
1010 s32 e1000_setup_link_generic(struct e1000_hw *hw)
1011 {
1012 s32 ret_val;
1013
1014 DEBUGFUNC("e1000_setup_link_generic");
1015
1016 /* In the case of the phy reset being blocked, we already have a link.
1017 * We do not need to set it up again.
1018 */
1019 if (hw->phy.ops.check_reset_block && hw->phy.ops.check_reset_block(hw))
1020 return E1000_SUCCESS;
1021
1022 /* If requested flow control is set to default, set flow control
1023 * based on the EEPROM flow control settings.
1024 */
1025 if (hw->fc.requested_mode == e1000_fc_default) {
1026 ret_val = e1000_set_default_fc_generic(hw);
1027 if (ret_val)
1028 return ret_val;
1029 }
1030
1031 /* Save off the requested flow control mode for use later. Depending
1032 * on the link partner's capabilities, we may or may not use this mode.
1033 */
1034 hw->fc.current_mode = hw->fc.requested_mode;
1035
1036 DEBUGOUT1("After fix-ups FlowControl is now = %x\n",
1037 hw->fc.current_mode);
1038
1039 /* Call the necessary media_type subroutine to configure the link. */
1040 ret_val = hw->mac.ops.setup_physical_interface(hw);
1041 if (ret_val)
1042 return ret_val;
1043
1044 /* Initialize the flow control address, type, and PAUSE timer
1045 * registers to their default values. This is done even if flow
1046 * control is disabled, because it does not hurt anything to
1047 * initialize these registers.
1048 */
1049 DEBUGOUT("Initializing the Flow Control address, type and timer regs\n");
1050 E1000_WRITE_REG(hw, E1000_FCT, FLOW_CONTROL_TYPE);
1051 E1000_WRITE_REG(hw, E1000_FCAH, FLOW_CONTROL_ADDRESS_HIGH);
1052 E1000_WRITE_REG(hw, E1000_FCAL, FLOW_CONTROL_ADDRESS_LOW);
1053
1054 E1000_WRITE_REG(hw, E1000_FCTTV, hw->fc.pause_time);
1055
1056 return e1000_set_fc_watermarks_generic(hw);
1057 }
1058
1059 /**
1060 * e1000_commit_fc_settings_generic - Configure flow control
1061 * @hw: pointer to the HW structure
1062 *
1063 * Write the flow control settings to the Transmit Config Word Register (TXCW)
1064 * base on the flow control settings in e1000_mac_info.
1065 **/
1066 s32 e1000_commit_fc_settings_generic(struct e1000_hw *hw)
1067 {
1068 struct e1000_mac_info *mac = &hw->mac;
1069 u32 txcw;
1070
1071 DEBUGFUNC("e1000_commit_fc_settings_generic");
1072
1073 /* Check for a software override of the flow control settings, and
1074 * setup the device accordingly. If auto-negotiation is enabled, then
1075 * software will have to set the "PAUSE" bits to the correct value in
1076 * the Transmit Config Word Register (TXCW) and re-start auto-
1077 * negotiation. However, if auto-negotiation is disabled, then
1078 * software will have to manually configure the two flow control enable
1079 * bits in the CTRL register.
1080 *
1081 * The possible values of the "fc" parameter are:
1082 * 0: Flow control is completely disabled
1083 * 1: Rx flow control is enabled (we can receive pause frames,
1084 * but not send pause frames).
1085 * 2: Tx flow control is enabled (we can send pause frames but we
1086 * do not support receiving pause frames).
1087 * 3: Both Rx and Tx flow control (symmetric) are enabled.
1088 */
1089 switch (hw->fc.current_mode) {
1090 case e1000_fc_none:
1091 /* Flow control completely disabled by a software over-ride. */
1092 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
1093 break;
1094 case e1000_fc_rx_pause:
1095 /* Rx Flow control is enabled and Tx Flow control is disabled
1096 * by a software over-ride. Since there really isn't a way to
1097 * advertise that we are capable of Rx Pause ONLY, we will
1098 * advertise that we support both symmetric and asymmetric Rx
1099 * PAUSE. Later, we will disable the adapter's ability to send
1100 * PAUSE frames.
1101 */
1102 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1103 break;
1104 case e1000_fc_tx_pause:
1105 /* Tx Flow control is enabled, and Rx Flow control is disabled,
1106 * by a software over-ride.
1107 */
1108 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
1109 break;
1110 case e1000_fc_full:
1111 /* Flow control (both Rx and Tx) is enabled by a software
1112 * over-ride.
1113 */
1114 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
1115 break;
1116 default:
1117 DEBUGOUT("Flow control param set incorrectly\n");
1118 return -E1000_ERR_CONFIG;
1119 break;
1120 }
1121
1122 E1000_WRITE_REG(hw, E1000_TXCW, txcw);
1123 mac->txcw = txcw;
1124
1125 return E1000_SUCCESS;
1126 }
1127
1128 /**
1129 * e1000_poll_fiber_serdes_link_generic - Poll for link up
1130 * @hw: pointer to the HW structure
1131 *
1132 * Polls for link up by reading the status register, if link fails to come
1133 * up with auto-negotiation, then the link is forced if a signal is detected.
1134 **/
1135 s32 e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw)
1136 {
1137 struct e1000_mac_info *mac = &hw->mac;
1138 u32 i, status;
1139 s32 ret_val;
1140
1141 DEBUGFUNC("e1000_poll_fiber_serdes_link_generic");
1142
1143 /* If we have a signal (the cable is plugged in, or assumed true for
1144 * serdes media) then poll for a "Link-Up" indication in the Device
1145 * Status Register. Time-out if a link isn't seen in 500 milliseconds
1146 * seconds (Auto-negotiation should complete in less than 500
1147 * milliseconds even if the other end is doing it in SW).
1148 */
1149 for (i = 0; i < FIBER_LINK_UP_LIMIT; i++) {
1150 msec_delay(10);
1151 status = E1000_READ_REG(hw, E1000_STATUS);
1152 if (status & E1000_STATUS_LU)
1153 break;
1154 }
1155 if (i == FIBER_LINK_UP_LIMIT) {
1156 DEBUGOUT("Never got a valid link from auto-neg!!!\n");
1157 mac->autoneg_failed = true;
1158 /* AutoNeg failed to achieve a link, so we'll call
1159 * mac->check_for_link. This routine will force the
1160 * link up if we detect a signal. This will allow us to
1161 * communicate with non-autonegotiating link partners.
1162 */
1163 ret_val = mac->ops.check_for_link(hw);
1164 if (ret_val) {
1165 DEBUGOUT("Error while checking for link\n");
1166 return ret_val;
1167 }
1168 mac->autoneg_failed = false;
1169 } else {
1170 mac->autoneg_failed = false;
1171 DEBUGOUT("Valid Link Found\n");
1172 }
1173
1174 return E1000_SUCCESS;
1175 }
1176
1177 /**
1178 * e1000_setup_fiber_serdes_link_generic - Setup link for fiber/serdes
1179 * @hw: pointer to the HW structure
1180 *
1181 * Configures collision distance and flow control for fiber and serdes
1182 * links. Upon successful setup, poll for link.
1183 **/
1184 s32 e1000_setup_fiber_serdes_link_generic(struct e1000_hw *hw)
1185 {
1186 u32 ctrl;
1187 s32 ret_val;
1188
1189 DEBUGFUNC("e1000_setup_fiber_serdes_link_generic");
1190
1191 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1192
1193 /* Take the link out of reset */
1194 ctrl &= ~E1000_CTRL_LRST;
1195
1196 hw->mac.ops.config_collision_dist(hw);
1197
1198 ret_val = e1000_commit_fc_settings_generic(hw);
1199 if (ret_val)
1200 return ret_val;
1201
1202 /* Since auto-negotiation is enabled, take the link out of reset (the
1203 * link will be in reset, because we previously reset the chip). This
1204 * will restart auto-negotiation. If auto-negotiation is successful
1205 * then the link-up status bit will be set and the flow control enable
1206 * bits (RFCE and TFCE) will be set according to their negotiated value.
1207 */
1208 DEBUGOUT("Auto-negotiation enabled\n");
1209
1210 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1211 E1000_WRITE_FLUSH(hw);
1212 msec_delay(1);
1213
1214 /* For these adapters, the SW definable pin 1 is set when the optics
1215 * detect a signal. If we have a signal, then poll for a "Link-Up"
1216 * indication.
1217 */
1218 if (hw->phy.media_type == e1000_media_type_internal_serdes ||
1219 (E1000_READ_REG(hw, E1000_CTRL) & E1000_CTRL_SWDPIN1)) {
1220 ret_val = e1000_poll_fiber_serdes_link_generic(hw);
1221 } else {
1222 DEBUGOUT("No signal detected\n");
1223 }
1224
1225 return ret_val;
1226 }
1227
1228 /**
1229 * e1000_config_collision_dist_generic - Configure collision distance
1230 * @hw: pointer to the HW structure
1231 *
1232 * Configures the collision distance to the default value and is used
1233 * during link setup.
1234 **/
1235 static void e1000_config_collision_dist_generic(struct e1000_hw *hw)
1236 {
1237 u32 tctl;
1238
1239 DEBUGFUNC("e1000_config_collision_dist_generic");
1240
1241 tctl = E1000_READ_REG(hw, E1000_TCTL);
1242
1243 tctl &= ~E1000_TCTL_COLD;
1244 tctl |= E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT;
1245
1246 E1000_WRITE_REG(hw, E1000_TCTL, tctl);
1247 E1000_WRITE_FLUSH(hw);
1248 }
1249
1250 /**
1251 * e1000_set_fc_watermarks_generic - Set flow control high/low watermarks
1252 * @hw: pointer to the HW structure
1253 *
1254 * Sets the flow control high/low threshold (watermark) registers. If
1255 * flow control XON frame transmission is enabled, then set XON frame
1256 * transmission as well.
1257 **/
1258 s32 e1000_set_fc_watermarks_generic(struct e1000_hw *hw)
1259 {
1260 u32 fcrtl = 0, fcrth = 0;
1261
1262 DEBUGFUNC("e1000_set_fc_watermarks_generic");
1263
1264 /* Set the flow control receive threshold registers. Normally,
1265 * these registers will be set to a default threshold that may be
1266 * adjusted later by the driver's runtime code. However, if the
1267 * ability to transmit pause frames is not enabled, then these
1268 * registers will be set to 0.
1269 */
1270 if (hw->fc.current_mode & e1000_fc_tx_pause) {
1271 /* We need to set up the Receive Threshold high and low water
1272 * marks as well as (optionally) enabling the transmission of
1273 * XON frames.
1274 */
1275 fcrtl = hw->fc.low_water;
1276 if (hw->fc.send_xon)
1277 fcrtl |= E1000_FCRTL_XONE;
1278
1279 fcrth = hw->fc.high_water;
1280 }
1281 E1000_WRITE_REG(hw, E1000_FCRTL, fcrtl);
1282 E1000_WRITE_REG(hw, E1000_FCRTH, fcrth);
1283
1284 return E1000_SUCCESS;
1285 }
1286
1287 /**
1288 * e1000_force_mac_fc_generic - Force the MAC's flow control settings
1289 * @hw: pointer to the HW structure
1290 *
1291 * Force the MAC's flow control settings. Sets the TFCE and RFCE bits in the
1292 * device control register to reflect the adapter settings. TFCE and RFCE
1293 * need to be explicitly set by software when a copper PHY is used because
1294 * autonegotiation is managed by the PHY rather than the MAC. Software must
1295 * also configure these bits when link is forced on a fiber connection.
1296 **/
1297 s32 e1000_force_mac_fc_generic(struct e1000_hw *hw)
1298 {
1299 u32 ctrl;
1300
1301 DEBUGFUNC("e1000_force_mac_fc_generic");
1302
1303 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1304
1305 /* Because we didn't get link via the internal auto-negotiation
1306 * mechanism (we either forced link or we got link via PHY
1307 * auto-neg), we have to manually enable/disable transmit an
1308 * receive flow control.
1309 *
1310 * The "Case" statement below enables/disable flow control
1311 * according to the "hw->fc.current_mode" parameter.
1312 *
1313 * The possible values of the "fc" parameter are:
1314 * 0: Flow control is completely disabled
1315 * 1: Rx flow control is enabled (we can receive pause
1316 * frames but not send pause frames).
1317 * 2: Tx flow control is enabled (we can send pause frames
1318 * frames but we do not receive pause frames).
1319 * 3: Both Rx and Tx flow control (symmetric) is enabled.
1320 * other: No other values should be possible at this point.
1321 */
1322 DEBUGOUT1("hw->fc.current_mode = %u\n", hw->fc.current_mode);
1323
1324 switch (hw->fc.current_mode) {
1325 case e1000_fc_none:
1326 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
1327 break;
1328 case e1000_fc_rx_pause:
1329 ctrl &= (~E1000_CTRL_TFCE);
1330 ctrl |= E1000_CTRL_RFCE;
1331 break;
1332 case e1000_fc_tx_pause:
1333 ctrl &= (~E1000_CTRL_RFCE);
1334 ctrl |= E1000_CTRL_TFCE;
1335 break;
1336 case e1000_fc_full:
1337 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
1338 break;
1339 default:
1340 DEBUGOUT("Flow control param set incorrectly\n");
1341 return -E1000_ERR_CONFIG;
1342 }
1343
1344 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1345
1346 return E1000_SUCCESS;
1347 }
1348
1349 /**
1350 * e1000_config_fc_after_link_up_generic - Configures flow control after link
1351 * @hw: pointer to the HW structure
1352 *
1353 * Checks the status of auto-negotiation after link up to ensure that the
1354 * speed and duplex were not forced. If the link needed to be forced, then
1355 * flow control needs to be forced also. If auto-negotiation is enabled
1356 * and did not fail, then we configure flow control based on our link
1357 * partner.
1358 **/
1359 s32 e1000_config_fc_after_link_up_generic(struct e1000_hw *hw)
1360 {
1361 struct e1000_mac_info *mac = &hw->mac;
1362 s32 ret_val = E1000_SUCCESS;
1363 u32 pcs_status_reg, pcs_adv_reg, pcs_lp_ability_reg, pcs_ctrl_reg;
1364 u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg;
1365 u16 speed, duplex;
1366
1367 DEBUGFUNC("e1000_config_fc_after_link_up_generic");
1368
1369 /* Check for the case where we have fiber media and auto-neg failed
1370 * so we had to force link. In this case, we need to force the
1371 * configuration of the MAC to match the "fc" parameter.
1372 */
1373 if (mac->autoneg_failed) {
1374 if (hw->phy.media_type == e1000_media_type_fiber ||
1375 hw->phy.media_type == e1000_media_type_internal_serdes)
1376 ret_val = e1000_force_mac_fc_generic(hw);
1377 } else {
1378 if (hw->phy.media_type == e1000_media_type_copper)
1379 ret_val = e1000_force_mac_fc_generic(hw);
1380 }
1381
1382 if (ret_val) {
1383 DEBUGOUT("Error forcing flow control settings\n");
1384 return ret_val;
1385 }
1386
1387 /* Check for the case where we have copper media and auto-neg is
1388 * enabled. In this case, we need to check and see if Auto-Neg
1389 * has completed, and if so, how the PHY and link partner has
1390 * flow control configured.
1391 */
1392 if ((hw->phy.media_type == e1000_media_type_copper) && mac->autoneg) {
1393 /* Read the MII Status Register and check to see if AutoNeg
1394 * has completed. We read this twice because this reg has
1395 * some "sticky" (latched) bits.
1396 */
1397 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg);
1398 if (ret_val)
1399 return ret_val;
1400 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg);
1401 if (ret_val)
1402 return ret_val;
1403
1404 if (!(mii_status_reg & MII_SR_AUTONEG_COMPLETE)) {
1405 DEBUGOUT("Copper PHY and Auto Neg has not completed.\n");
1406 return ret_val;
1407 }
1408
1409 /* The AutoNeg process has completed, so we now need to
1410 * read both the Auto Negotiation Advertisement
1411 * Register (Address 4) and the Auto_Negotiation Base
1412 * Page Ability Register (Address 5) to determine how
1413 * flow control was negotiated.
1414 */
1415 ret_val = hw->phy.ops.read_reg(hw, PHY_AUTONEG_ADV,
1416 &mii_nway_adv_reg);
1417 if (ret_val)
1418 return ret_val;
1419 ret_val = hw->phy.ops.read_reg(hw, PHY_LP_ABILITY,
1420 &mii_nway_lp_ability_reg);
1421 if (ret_val)
1422 return ret_val;
1423
1424 /* Two bits in the Auto Negotiation Advertisement Register
1425 * (Address 4) and two bits in the Auto Negotiation Base
1426 * Page Ability Register (Address 5) determine flow control
1427 * for both the PHY and the link partner. The following
1428 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
1429 * 1999, describes these PAUSE resolution bits and how flow
1430 * control is determined based upon these settings.
1431 * NOTE: DC = Don't Care
1432 *
1433 * LOCAL DEVICE | LINK PARTNER
1434 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
1435 *-------|---------|-------|---------|--------------------
1436 * 0 | 0 | DC | DC | e1000_fc_none
1437 * 0 | 1 | 0 | DC | e1000_fc_none
1438 * 0 | 1 | 1 | 0 | e1000_fc_none
1439 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause
1440 * 1 | 0 | 0 | DC | e1000_fc_none
1441 * 1 | DC | 1 | DC | e1000_fc_full
1442 * 1 | 1 | 0 | 0 | e1000_fc_none
1443 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause
1444 *
1445 * Are both PAUSE bits set to 1? If so, this implies
1446 * Symmetric Flow Control is enabled at both ends. The
1447 * ASM_DIR bits are irrelevant per the spec.
1448 *
1449 * For Symmetric Flow Control:
1450 *
1451 * LOCAL DEVICE | LINK PARTNER
1452 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1453 *-------|---------|-------|---------|--------------------
1454 * 1 | DC | 1 | DC | E1000_fc_full
1455 *
1456 */
1457 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1458 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
1459 /* Now we need to check if the user selected Rx ONLY
1460 * of pause frames. In this case, we had to advertise
1461 * FULL flow control because we could not advertise Rx
1462 * ONLY. Hence, we must now check to see if we need to
1463 * turn OFF the TRANSMISSION of PAUSE frames.
1464 */
1465 if (hw->fc.requested_mode == e1000_fc_full) {
1466 hw->fc.current_mode = e1000_fc_full;
1467 DEBUGOUT("Flow Control = FULL.\n");
1468 } else {
1469 hw->fc.current_mode = e1000_fc_rx_pause;
1470 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1471 }
1472 }
1473 /* For receiving PAUSE frames ONLY.
1474 *
1475 * LOCAL DEVICE | LINK PARTNER
1476 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1477 *-------|---------|-------|---------|--------------------
1478 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause
1479 */
1480 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1481 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1482 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1483 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1484 hw->fc.current_mode = e1000_fc_tx_pause;
1485 DEBUGOUT("Flow Control = Tx PAUSE frames only.\n");
1486 }
1487 /* For transmitting PAUSE frames ONLY.
1488 *
1489 * LOCAL DEVICE | LINK PARTNER
1490 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1491 *-------|---------|-------|---------|--------------------
1492 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause
1493 */
1494 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1495 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1496 !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1497 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1498 hw->fc.current_mode = e1000_fc_rx_pause;
1499 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1500 } else {
1501 /* Per the IEEE spec, at this point flow control
1502 * should be disabled.
1503 */
1504 hw->fc.current_mode = e1000_fc_none;
1505 DEBUGOUT("Flow Control = NONE.\n");
1506 }
1507
1508 /* Now we need to do one last check... If we auto-
1509 * negotiated to HALF DUPLEX, flow control should not be
1510 * enabled per IEEE 802.3 spec.
1511 */
1512 ret_val = mac->ops.get_link_up_info(hw, &speed, &duplex);
1513 if (ret_val) {
1514 DEBUGOUT("Error getting link speed and duplex\n");
1515 return ret_val;
1516 }
1517
1518 if (duplex == HALF_DUPLEX)
1519 hw->fc.current_mode = e1000_fc_none;
1520
1521 /* Now we call a subroutine to actually force the MAC
1522 * controller to use the correct flow control settings.
1523 */
1524 ret_val = e1000_force_mac_fc_generic(hw);
1525 if (ret_val) {
1526 DEBUGOUT("Error forcing flow control settings\n");
1527 return ret_val;
1528 }
1529 }
1530
1531 /* Check for the case where we have SerDes media and auto-neg is
1532 * enabled. In this case, we need to check and see if Auto-Neg
1533 * has completed, and if so, how the PHY and link partner has
1534 * flow control configured.
1535 */
1536 if ((hw->phy.media_type == e1000_media_type_internal_serdes) &&
1537 mac->autoneg) {
1538 /* Read the PCS_LSTS and check to see if AutoNeg
1539 * has completed.
1540 */
1541 pcs_status_reg = E1000_READ_REG(hw, E1000_PCS_LSTAT);
1542
1543 if (!(pcs_status_reg & E1000_PCS_LSTS_AN_COMPLETE)) {
1544 DEBUGOUT("PCS Auto Neg has not completed.\n");
1545 return ret_val;
1546 }
1547
1548 /* The AutoNeg process has completed, so we now need to
1549 * read both the Auto Negotiation Advertisement
1550 * Register (PCS_ANADV) and the Auto_Negotiation Base
1551 * Page Ability Register (PCS_LPAB) to determine how
1552 * flow control was negotiated.
1553 */
1554 pcs_adv_reg = E1000_READ_REG(hw, E1000_PCS_ANADV);
1555 pcs_lp_ability_reg = E1000_READ_REG(hw, E1000_PCS_LPAB);
1556
1557 /* Two bits in the Auto Negotiation Advertisement Register
1558 * (PCS_ANADV) and two bits in the Auto Negotiation Base
1559 * Page Ability Register (PCS_LPAB) determine flow control
1560 * for both the PHY and the link partner. The following
1561 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
1562 * 1999, describes these PAUSE resolution bits and how flow
1563 * control is determined based upon these settings.
1564 * NOTE: DC = Don't Care
1565 *
1566 * LOCAL DEVICE | LINK PARTNER
1567 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
1568 *-------|---------|-------|---------|--------------------
1569 * 0 | 0 | DC | DC | e1000_fc_none
1570 * 0 | 1 | 0 | DC | e1000_fc_none
1571 * 0 | 1 | 1 | 0 | e1000_fc_none
1572 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause
1573 * 1 | 0 | 0 | DC | e1000_fc_none
1574 * 1 | DC | 1 | DC | e1000_fc_full
1575 * 1 | 1 | 0 | 0 | e1000_fc_none
1576 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause
1577 *
1578 * Are both PAUSE bits set to 1? If so, this implies
1579 * Symmetric Flow Control is enabled at both ends. The
1580 * ASM_DIR bits are irrelevant per the spec.
1581 *
1582 * For Symmetric Flow Control:
1583 *
1584 * LOCAL DEVICE | LINK PARTNER
1585 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1586 *-------|---------|-------|---------|--------------------
1587 * 1 | DC | 1 | DC | e1000_fc_full
1588 *
1589 */
1590 if ((pcs_adv_reg & E1000_TXCW_PAUSE) &&
1591 (pcs_lp_ability_reg & E1000_TXCW_PAUSE)) {
1592 /* Now we need to check if the user selected Rx ONLY
1593 * of pause frames. In this case, we had to advertise
1594 * FULL flow control because we could not advertise Rx
1595 * ONLY. Hence, we must now check to see if we need to
1596 * turn OFF the TRANSMISSION of PAUSE frames.
1597 */
1598 if (hw->fc.requested_mode == e1000_fc_full) {
1599 hw->fc.current_mode = e1000_fc_full;
1600 DEBUGOUT("Flow Control = FULL.\n");
1601 } else {
1602 hw->fc.current_mode = e1000_fc_rx_pause;
1603 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1604 }
1605 }
1606 /* For receiving PAUSE frames ONLY.
1607 *
1608 * LOCAL DEVICE | LINK PARTNER
1609 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1610 *-------|---------|-------|---------|--------------------
1611 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause
1612 */
1613 else if (!(pcs_adv_reg & E1000_TXCW_PAUSE) &&
1614 (pcs_adv_reg & E1000_TXCW_ASM_DIR) &&
1615 (pcs_lp_ability_reg & E1000_TXCW_PAUSE) &&
1616 (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) {
1617 hw->fc.current_mode = e1000_fc_tx_pause;
1618 DEBUGOUT("Flow Control = Tx PAUSE frames only.\n");
1619 }
1620 /* For transmitting PAUSE frames ONLY.
1621 *
1622 * LOCAL DEVICE | LINK PARTNER
1623 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1624 *-------|---------|-------|---------|--------------------
1625 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause
1626 */
1627 else if ((pcs_adv_reg & E1000_TXCW_PAUSE) &&
1628 (pcs_adv_reg & E1000_TXCW_ASM_DIR) &&
1629 !(pcs_lp_ability_reg & E1000_TXCW_PAUSE) &&
1630 (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) {
1631 hw->fc.current_mode = e1000_fc_rx_pause;
1632 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n");
1633 } else {
1634 /* Per the IEEE spec, at this point flow control
1635 * should be disabled.
1636 */
1637 hw->fc.current_mode = e1000_fc_none;
1638 DEBUGOUT("Flow Control = NONE.\n");
1639 }
1640
1641 /* Now we call a subroutine to actually force the MAC
1642 * controller to use the correct flow control settings.
1643 */
1644 pcs_ctrl_reg = E1000_READ_REG(hw, E1000_PCS_LCTL);
1645 pcs_ctrl_reg |= E1000_PCS_LCTL_FORCE_FCTRL;
1646 E1000_WRITE_REG(hw, E1000_PCS_LCTL, pcs_ctrl_reg);
1647
1648 ret_val = e1000_force_mac_fc_generic(hw);
1649 if (ret_val) {
1650 DEBUGOUT("Error forcing flow control settings\n");
1651 return ret_val;
1652 }
1653 }
1654
1655 return E1000_SUCCESS;
1656 }
1657
1658 /**
1659 * e1000_get_speed_and_duplex_copper_generic - Retrieve current speed/duplex
1660 * @hw: pointer to the HW structure
1661 * @speed: stores the current speed
1662 * @duplex: stores the current duplex
1663 *
1664 * Read the status register for the current speed/duplex and store the current
1665 * speed and duplex for copper connections.
1666 **/
1667 s32 e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, u16 *speed,
1668 u16 *duplex)
1669 {
1670 u32 status;
1671
1672 DEBUGFUNC("e1000_get_speed_and_duplex_copper_generic");
1673
1674 status = E1000_READ_REG(hw, E1000_STATUS);
1675 if (status & E1000_STATUS_SPEED_1000) {
1676 *speed = SPEED_1000;
1677 DEBUGOUT("1000 Mbs, ");
1678 } else if (status & E1000_STATUS_SPEED_100) {
1679 *speed = SPEED_100;
1680 DEBUGOUT("100 Mbs, ");
1681 } else {
1682 *speed = SPEED_10;
1683 DEBUGOUT("10 Mbs, ");
1684 }
1685
1686 if (status & E1000_STATUS_FD) {
1687 *duplex = FULL_DUPLEX;
1688 DEBUGOUT("Full Duplex\n");
1689 } else {
1690 *duplex = HALF_DUPLEX;
1691 DEBUGOUT("Half Duplex\n");
1692 }
1693
1694 return E1000_SUCCESS;
1695 }
1696
1697 /**
1698 * e1000_get_speed_and_duplex_fiber_generic - Retrieve current speed/duplex
1699 * @hw: pointer to the HW structure
1700 * @speed: stores the current speed
1701 * @duplex: stores the current duplex
1702 *
1703 * Sets the speed and duplex to gigabit full duplex (the only possible option)
1704 * for fiber/serdes links.
1705 **/
1706 s32 e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw E1000_UNUSEDARG *hw,
1707 u16 *speed, u16 *duplex)
1708 {
1709 DEBUGFUNC("e1000_get_speed_and_duplex_fiber_serdes_generic");
1710
1711 *speed = SPEED_1000;
1712 *duplex = FULL_DUPLEX;
1713
1714 return E1000_SUCCESS;
1715 }
1716
1717 /**
1718 * e1000_get_auto_rd_done_generic - Check for auto read completion
1719 * @hw: pointer to the HW structure
1720 *
1721 * Check EEPROM for Auto Read done bit.
1722 **/
1723 s32 e1000_get_auto_rd_done_generic(struct e1000_hw *hw)
1724 {
1725 s32 i = 0;
1726
1727 DEBUGFUNC("e1000_get_auto_rd_done_generic");
1728
1729 while (i < AUTO_READ_DONE_TIMEOUT) {
1730 if (E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_AUTO_RD)
1731 break;
1732 msec_delay(1);
1733 i++;
1734 }
1735
1736 if (i == AUTO_READ_DONE_TIMEOUT) {
1737 DEBUGOUT("Auto read by HW from NVM has not completed.\n");
1738 return -E1000_ERR_RESET;
1739 }
1740
1741 return E1000_SUCCESS;
1742 }
1743
1744 /**
1745 * e1000_valid_led_default_generic - Verify a valid default LED config
1746 * @hw: pointer to the HW structure
1747 * @data: pointer to the NVM (EEPROM)
1748 *
1749 * Read the EEPROM for the current default LED configuration. If the
1750 * LED configuration is not valid, set to a valid LED configuration.
1751 **/
1752 s32 e1000_valid_led_default_generic(struct e1000_hw *hw, u16 *data)
1753 {
1754 s32 ret_val;
1755
1756 DEBUGFUNC("e1000_valid_led_default_generic");
1757
1758 ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
1759 if (ret_val) {
1760 DEBUGOUT("NVM Read Error\n");
1761 return ret_val;
1762 }
1763
1764 if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF)
1765 *data = ID_LED_DEFAULT;
1766
1767 return E1000_SUCCESS;
1768 }
1769
1770 /**
1771 * e1000_id_led_init_generic -
1772 * @hw: pointer to the HW structure
1773 *
1774 **/
1775 s32 e1000_id_led_init_generic(struct e1000_hw *hw)
1776 {
1777 struct e1000_mac_info *mac = &hw->mac;
1778 s32 ret_val;
1779 const u32 ledctl_mask = 0x000000FF;
1780 const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON;
1781 const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
1782 u16 data, i, temp;
1783 const u16 led_mask = 0x0F;
1784
1785 DEBUGFUNC("e1000_id_led_init_generic");
1786
1787 ret_val = hw->nvm.ops.valid_led_default(hw, &data);
1788 if (ret_val)
1789 return ret_val;
1790
1791 mac->ledctl_default = E1000_READ_REG(hw, E1000_LEDCTL);
1792 mac->ledctl_mode1 = mac->ledctl_default;
1793 mac->ledctl_mode2 = mac->ledctl_default;
1794
1795 for (i = 0; i < 4; i++) {
1796 temp = (data >> (i << 2)) & led_mask;
1797 switch (temp) {
1798 case ID_LED_ON1_DEF2:
1799 case ID_LED_ON1_ON2:
1800 case ID_LED_ON1_OFF2:
1801 mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1802 mac->ledctl_mode1 |= ledctl_on << (i << 3);
1803 break;
1804 case ID_LED_OFF1_DEF2:
1805 case ID_LED_OFF1_ON2:
1806 case ID_LED_OFF1_OFF2:
1807 mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1808 mac->ledctl_mode1 |= ledctl_off << (i << 3);
1809 break;
1810 default:
1811 /* Do nothing */
1812 break;
1813 }
1814 switch (temp) {
1815 case ID_LED_DEF1_ON2:
1816 case ID_LED_ON1_ON2:
1817 case ID_LED_OFF1_ON2:
1818 mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1819 mac->ledctl_mode2 |= ledctl_on << (i << 3);
1820 break;
1821 case ID_LED_DEF1_OFF2:
1822 case ID_LED_ON1_OFF2:
1823 case ID_LED_OFF1_OFF2:
1824 mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1825 mac->ledctl_mode2 |= ledctl_off << (i << 3);
1826 break;
1827 default:
1828 /* Do nothing */
1829 break;
1830 }
1831 }
1832
1833 return E1000_SUCCESS;
1834 }
1835
1836 /**
1837 * e1000_setup_led_generic - Configures SW controllable LED
1838 * @hw: pointer to the HW structure
1839 *
1840 * This prepares the SW controllable LED for use and saves the current state
1841 * of the LED so it can be later restored.
1842 **/
1843 s32 e1000_setup_led_generic(struct e1000_hw *hw)
1844 {
1845 u32 ledctl;
1846
1847 DEBUGFUNC("e1000_setup_led_generic");
1848
1849 if (hw->mac.ops.setup_led != e1000_setup_led_generic)
1850 return -E1000_ERR_CONFIG;
1851
1852 if (hw->phy.media_type == e1000_media_type_fiber) {
1853 ledctl = E1000_READ_REG(hw, E1000_LEDCTL);
1854 hw->mac.ledctl_default = ledctl;
1855 /* Turn off LED0 */
1856 ledctl &= ~(E1000_LEDCTL_LED0_IVRT | E1000_LEDCTL_LED0_BLINK |
1857 E1000_LEDCTL_LED0_MODE_MASK);
1858 ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
1859 E1000_LEDCTL_LED0_MODE_SHIFT);
1860 E1000_WRITE_REG(hw, E1000_LEDCTL, ledctl);
1861 } else if (hw->phy.media_type == e1000_media_type_copper) {
1862 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode1);
1863 }
1864
1865 return E1000_SUCCESS;
1866 }
1867
1868 /**
1869 * e1000_cleanup_led_generic - Set LED config to default operation
1870 * @hw: pointer to the HW structure
1871 *
1872 * Remove the current LED configuration and set the LED configuration
1873 * to the default value, saved from the EEPROM.
1874 **/
1875 s32 e1000_cleanup_led_generic(struct e1000_hw *hw)
1876 {
1877 DEBUGFUNC("e1000_cleanup_led_generic");
1878
1879 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_default);
1880 return E1000_SUCCESS;
1881 }
1882
1883 /**
1884 * e1000_blink_led_generic - Blink LED
1885 * @hw: pointer to the HW structure
1886 *
1887 * Blink the LEDs which are set to be on.
1888 **/
1889 s32 e1000_blink_led_generic(struct e1000_hw *hw)
1890 {
1891 u32 ledctl_blink = 0;
1892 u32 i;
1893
1894 DEBUGFUNC("e1000_blink_led_generic");
1895
1896 if (hw->phy.media_type == e1000_media_type_fiber) {
1897 /* always blink LED0 for PCI-E fiber */
1898 ledctl_blink = E1000_LEDCTL_LED0_BLINK |
1899 (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
1900 } else {
1901 /* Set the blink bit for each LED that's "on" (0x0E)
1902 * (or "off" if inverted) in ledctl_mode2. The blink
1903 * logic in hardware only works when mode is set to "on"
1904 * so it must be changed accordingly when the mode is
1905 * "off" and inverted.
1906 */
1907 ledctl_blink = hw->mac.ledctl_mode2;
1908 for (i = 0; i < 32; i += 8) {
1909 u32 mode = (hw->mac.ledctl_mode2 >> i) &
1910 E1000_LEDCTL_LED0_MODE_MASK;
1911 u32 led_default = hw->mac.ledctl_default >> i;
1912
1913 if ((!(led_default & E1000_LEDCTL_LED0_IVRT) &&
1914 (mode == E1000_LEDCTL_MODE_LED_ON)) ||
1915 ((led_default & E1000_LEDCTL_LED0_IVRT) &&
1916 (mode == E1000_LEDCTL_MODE_LED_OFF))) {
1917 ledctl_blink &=
1918 ~(E1000_LEDCTL_LED0_MODE_MASK << i);
1919 ledctl_blink |= (E1000_LEDCTL_LED0_BLINK |
1920 E1000_LEDCTL_MODE_LED_ON) << i;
1921 }
1922 }
1923 }
1924
1925 E1000_WRITE_REG(hw, E1000_LEDCTL, ledctl_blink);
1926
1927 return E1000_SUCCESS;
1928 }
1929
1930 /**
1931 * e1000_led_on_generic - Turn LED on
1932 * @hw: pointer to the HW structure
1933 *
1934 * Turn LED on.
1935 **/
1936 s32 e1000_led_on_generic(struct e1000_hw *hw)
1937 {
1938 u32 ctrl;
1939
1940 DEBUGFUNC("e1000_led_on_generic");
1941
1942 switch (hw->phy.media_type) {
1943 case e1000_media_type_fiber:
1944 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1945 ctrl &= ~E1000_CTRL_SWDPIN0;
1946 ctrl |= E1000_CTRL_SWDPIO0;
1947 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1948 break;
1949 case e1000_media_type_copper:
1950 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode2);
1951 break;
1952 default:
1953 break;
1954 }
1955
1956 return E1000_SUCCESS;
1957 }
1958
1959 /**
1960 * e1000_led_off_generic - Turn LED off
1961 * @hw: pointer to the HW structure
1962 *
1963 * Turn LED off.
1964 **/
1965 s32 e1000_led_off_generic(struct e1000_hw *hw)
1966 {
1967 u32 ctrl;
1968
1969 DEBUGFUNC("e1000_led_off_generic");
1970
1971 switch (hw->phy.media_type) {
1972 case e1000_media_type_fiber:
1973 ctrl = E1000_READ_REG(hw, E1000_CTRL);
1974 ctrl |= E1000_CTRL_SWDPIN0;
1975 ctrl |= E1000_CTRL_SWDPIO0;
1976 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1977 break;
1978 case e1000_media_type_copper:
1979 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode1);
1980 break;
1981 default:
1982 break;
1983 }
1984
1985 return E1000_SUCCESS;
1986 }
1987
1988 /**
1989 * e1000_set_pcie_no_snoop_generic - Set PCI-express capabilities
1990 * @hw: pointer to the HW structure
1991 * @no_snoop: bitmap of snoop events
1992 *
1993 * Set the PCI-express register to snoop for events enabled in 'no_snoop'.
1994 **/
1995 void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, u32 no_snoop)
1996 {
1997 u32 gcr;
1998
1999 DEBUGFUNC("e1000_set_pcie_no_snoop_generic");
2000
2001 if (hw->bus.type != e1000_bus_type_pci_express)
2002 return;
2003
2004 if (no_snoop) {
2005 gcr = E1000_READ_REG(hw, E1000_GCR);
2006 gcr &= ~(PCIE_NO_SNOOP_ALL);
2007 gcr |= no_snoop;
2008 E1000_WRITE_REG(hw, E1000_GCR, gcr);
2009 }
2010 }
2011
2012 /**
2013 * e1000_disable_pcie_master_generic - Disables PCI-express master access
2014 * @hw: pointer to the HW structure
2015 *
2016 * Returns E1000_SUCCESS if successful, else returns -10
2017 * (-E1000_ERR_MASTER_REQUESTS_PENDING) if master disable bit has not caused
2018 * the master requests to be disabled.
2019 *
2020 * Disables PCI-Express master access and verifies there are no pending
2021 * requests.
2022 **/
2023 s32 e1000_disable_pcie_master_generic(struct e1000_hw *hw)
2024 {
2025 u32 ctrl;
2026 s32 timeout = MASTER_DISABLE_TIMEOUT;
2027
2028 DEBUGFUNC("e1000_disable_pcie_master_generic");
2029
2030 if (hw->bus.type != e1000_bus_type_pci_express)
2031 return E1000_SUCCESS;
2032
2033 ctrl = E1000_READ_REG(hw, E1000_CTRL);
2034 ctrl |= E1000_CTRL_GIO_MASTER_DISABLE;
2035 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
2036
2037 while (timeout) {
2038 if (!(E1000_READ_REG(hw, E1000_STATUS) &
2039 E1000_STATUS_GIO_MASTER_ENABLE) ||
2040 E1000_REMOVED(hw->hw_addr))
2041 break;
2042 usec_delay(100);
2043 timeout--;
2044 }
2045
2046 if (!timeout) {
2047 DEBUGOUT("Master requests are pending.\n");
2048 return -E1000_ERR_MASTER_REQUESTS_PENDING;
2049 }
2050
2051 return E1000_SUCCESS;
2052 }
2053
2054 /**
2055 * e1000_reset_adaptive_generic - Reset Adaptive Interframe Spacing
2056 * @hw: pointer to the HW structure
2057 *
2058 * Reset the Adaptive Interframe Spacing throttle to default values.
2059 **/
2060 void e1000_reset_adaptive_generic(struct e1000_hw *hw)
2061 {
2062 struct e1000_mac_info *mac = &hw->mac;
2063
2064 DEBUGFUNC("e1000_reset_adaptive_generic");
2065
2066 if (!mac->adaptive_ifs) {
2067 DEBUGOUT("Not in Adaptive IFS mode!\n");
2068 return;
2069 }
2070
2071 mac->current_ifs_val = 0;
2072 mac->ifs_min_val = IFS_MIN;
2073 mac->ifs_max_val = IFS_MAX;
2074 mac->ifs_step_size = IFS_STEP;
2075 mac->ifs_ratio = IFS_RATIO;
2076
2077 mac->in_ifs_mode = false;
2078 E1000_WRITE_REG(hw, E1000_AIT, 0);
2079 }
2080
2081 /**
2082 * e1000_update_adaptive_generic - Update Adaptive Interframe Spacing
2083 * @hw: pointer to the HW structure
2084 *
2085 * Update the Adaptive Interframe Spacing Throttle value based on the
2086 * time between transmitted packets and time between collisions.
2087 **/
2088 void e1000_update_adaptive_generic(struct e1000_hw *hw)
2089 {
2090 struct e1000_mac_info *mac = &hw->mac;
2091
2092 DEBUGFUNC("e1000_update_adaptive_generic");
2093
2094 if (!mac->adaptive_ifs) {
2095 DEBUGOUT("Not in Adaptive IFS mode!\n");
2096 return;
2097 }
2098
2099 if ((mac->collision_delta * mac->ifs_ratio) > mac->tx_packet_delta) {
2100 if (mac->tx_packet_delta > MIN_NUM_XMITS) {
2101 mac->in_ifs_mode = true;
2102 if (mac->current_ifs_val < mac->ifs_max_val) {
2103 if (!mac->current_ifs_val)
2104 mac->current_ifs_val = mac->ifs_min_val;
2105 else
2106 mac->current_ifs_val +=
2107 mac->ifs_step_size;
2108 E1000_WRITE_REG(hw, E1000_AIT,
2109 mac->current_ifs_val);
2110 }
2111 }
2112 } else {
2113 if (mac->in_ifs_mode &&
2114 (mac->tx_packet_delta <= MIN_NUM_XMITS)) {
2115 mac->current_ifs_val = 0;
2116 mac->in_ifs_mode = false;
2117 E1000_WRITE_REG(hw, E1000_AIT, 0);
2118 }
2119 }
2120 }
2121
2122 /**
2123 * e1000_validate_mdi_setting_generic - Verify MDI/MDIx settings
2124 * @hw: pointer to the HW structure
2125 *
2126 * Verify that when not using auto-negotiation that MDI/MDIx is correctly
2127 * set, which is forced to MDI mode only.
2128 **/
2129 static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw)
2130 {
2131 DEBUGFUNC("e1000_validate_mdi_setting_generic");
2132
2133 if (!hw->mac.autoneg && (hw->phy.mdix == 0 || hw->phy.mdix == 3)) {
2134 DEBUGOUT("Invalid MDI setting detected\n");
2135 hw->phy.mdix = 1;
2136 return -E1000_ERR_CONFIG;
2137 }
2138
2139 return E1000_SUCCESS;
2140 }
2141
2142 /**
2143 * e1000_validate_mdi_setting_crossover_generic - Verify MDI/MDIx settings
2144 * @hw: pointer to the HW structure
2145 *
2146 * Validate the MDI/MDIx setting, allowing for auto-crossover during forced
2147 * operation.
2148 **/
2149 s32 e1000_validate_mdi_setting_crossover_generic(struct e1000_hw E1000_UNUSEDARG *hw)
2150 {
2151 DEBUGFUNC("e1000_validate_mdi_setting_crossover_generic");
2152
2153 return E1000_SUCCESS;
2154 }
2155
2156 /**
2157 * e1000_write_8bit_ctrl_reg_generic - Write a 8bit CTRL register
2158 * @hw: pointer to the HW structure
2159 * @reg: 32bit register offset such as E1000_SCTL
2160 * @offset: register offset to write to
2161 * @data: data to write at register offset
2162 *
2163 * Writes an address/data control type register. There are several of these
2164 * and they all have the format address << 8 | data and bit 31 is polled for
2165 * completion.
2166 **/
2167 s32 e1000_write_8bit_ctrl_reg_generic(struct e1000_hw *hw, u32 reg,
2168 u32 offset, u8 data)
2169 {
2170 u32 i, regvalue = 0;
2171
2172 DEBUGFUNC("e1000_write_8bit_ctrl_reg_generic");
2173
2174 /* Set up the address and data */
2175 regvalue = ((u32)data) | (offset << E1000_GEN_CTL_ADDRESS_SHIFT);
2176 E1000_WRITE_REG(hw, reg, regvalue);
2177
2178 /* Poll the ready bit to see if the MDI read completed */
2179 for (i = 0; i < E1000_GEN_POLL_TIMEOUT; i++) {
2180 usec_delay(5);
2181 regvalue = E1000_READ_REG(hw, reg);
2182 if (regvalue & E1000_GEN_CTL_READY)
2183 break;
2184 }
2185 if (!(regvalue & E1000_GEN_CTL_READY)) {
2186 DEBUGOUT1("Reg %08x did not indicate ready\n", reg);
2187 return -E1000_ERR_PHY;
2188 }
2189
2190 return E1000_SUCCESS;
2191 }
2192
2193 /**
2194 * e1000_get_hw_semaphore - Acquire hardware semaphore
2195 * @hw: pointer to the HW structure
2196 *
2197 * Acquire the HW semaphore to access the PHY or NVM
2198 **/
2199 s32 e1000_get_hw_semaphore(struct e1000_hw *hw)
2200 {
2201 u32 swsm;
2202 s32 fw_timeout = hw->nvm.word_size + 1;
2203 s32 sw_timeout = hw->nvm.word_size + 1;
2204 s32 i = 0;
2205
2206 DEBUGFUNC("e1000_get_hw_semaphore");
2207
2208 /* _82571 */
2209 /* If we have timedout 3 times on trying to acquire
2210 * the inter-port SMBI semaphore, there is old code
2211 * operating on the other port, and it is not
2212 * releasing SMBI. Modify the number of times that
2213 * we try for the semaphore to interwork with this
2214 * older code.
2215 */
2216 if (hw->dev_spec._82571.smb_counter > 2)
2217 sw_timeout = 1;
2218
2219
2220 /* Get the SW semaphore */
2221 while (i < sw_timeout) {
2222 swsm = E1000_READ_REG(hw, E1000_SWSM);
2223 if (!(swsm & E1000_SWSM_SMBI))
2224 break;
2225
2226 usec_delay(50);
2227 i++;
2228 }
2229
2230 if (i == sw_timeout) {
2231 DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
2232 hw->dev_spec._82571.smb_counter++;
2233 }
2234
2235 /* In rare circumstances, the SW semaphore may already be held
2236 * unintentionally. Clear the semaphore once before giving up.
2237 */
2238 if (hw->dev_spec._82575.clear_semaphore_once) {
2239 hw->dev_spec._82575.clear_semaphore_once = false;
2240 e1000_put_hw_semaphore(hw);
2241 for (i = 0; i < fw_timeout; i++) {
2242 swsm = E1000_READ_REG(hw, E1000_SWSM);
2243 if (!(swsm & E1000_SWSM_SMBI))
2244 break;
2245
2246 usec_delay(50);
2247 }
2248 }
2249
2250 /* Get the FW semaphore. */
2251 for (i = 0; i < fw_timeout; i++) {
2252 swsm = E1000_READ_REG(hw, E1000_SWSM);
2253 E1000_WRITE_REG(hw, E1000_SWSM, swsm | E1000_SWSM_SWESMBI);
2254
2255 /* Semaphore acquired if bit latched */
2256 if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI)
2257 break;
2258
2259 usec_delay(50);
2260 }
2261
2262 if (i == fw_timeout) {
2263 /* Release semaphores */
2264 e1000_put_hw_semaphore(hw);
2265 DEBUGOUT("Driver can't access the NVM\n");
2266 return -E1000_ERR_NVM;
2267 }
2268
2269 return E1000_SUCCESS;
2270 }
2271
2272 /**
2273 * e1000_put_hw_semaphore - Release hardware semaphore
2274 * @hw: pointer to the HW structure
2275 *
2276 * Release hardware semaphore used to access the PHY or NVM
2277 **/
2278 void e1000_put_hw_semaphore(struct e1000_hw *hw)
2279 {
2280 u32 swsm;
2281
2282 DEBUGFUNC("e1000_put_hw_semaphore");
2283
2284 swsm = E1000_READ_REG(hw, E1000_SWSM);
2285
2286 swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI);
2287
2288 E1000_WRITE_REG(hw, E1000_SWSM, swsm);
2289 }
2290
2291
2292 /**
2293 * e1000_acquire_swfw_sync - Acquire SW/FW semaphore
2294 * @hw: pointer to the HW structure
2295 * @mask: specifies which semaphore to acquire
2296 *
2297 * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
2298 * will also specify which port we're acquiring the lock for.
2299 **/
2300 s32
2301 e1000_acquire_swfw_sync(struct e1000_hw *hw, u16 mask)
2302 {
2303 u32 swfw_sync;
2304 u32 swmask = mask;
2305 u32 fwmask = mask << 16;
2306 s32 ret_val = E1000_SUCCESS;
2307 s32 i = 0, timeout = 200;
2308
2309 DEBUGFUNC("e1000_acquire_swfw_sync");
2310 ASSERT_NO_LOCKS();
2311 while (i < timeout) {
2312 if (e1000_get_hw_semaphore(hw)) {
2313 ret_val = -E1000_ERR_SWFW_SYNC;
2314 goto out;
2315 }
2316
2317 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
2318 if (!(swfw_sync & (fwmask | swmask)))
2319 break;
2320
2321 /*
2322 * Firmware currently using resource (fwmask)
2323 * or other software thread using resource (swmask)
2324 */
2325 e1000_put_hw_semaphore(hw);
2326 msec_delay_irq(5);
2327 i++;
2328 }
2329
2330 if (i == timeout) {
2331 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
2332 ret_val = -E1000_ERR_SWFW_SYNC;
2333 goto out;
2334 }
2335
2336 swfw_sync |= swmask;
2337 E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
2338
2339 e1000_put_hw_semaphore(hw);
2340
2341 out:
2342 return ret_val;
2343 }
2344
2345 /**
2346 * e1000_release_swfw_sync - Release SW/FW semaphore
2347 * @hw: pointer to the HW structure
2348 * @mask: specifies which semaphore to acquire
2349 *
2350 * Release the SW/FW semaphore used to access the PHY or NVM. The mask
2351 * will also specify which port we're releasing the lock for.
2352 **/
2353 void
2354 e1000_release_swfw_sync(struct e1000_hw *hw, u16 mask)
2355 {
2356 u32 swfw_sync;
2357
2358 DEBUGFUNC("e1000_release_swfw_sync");
2359
2360 while (e1000_get_hw_semaphore(hw) != E1000_SUCCESS)
2361 ; /* Empty */
2362
2363 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
2364 swfw_sync &= (u32)~mask;
2365 E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
2366
2367 e1000_put_hw_semaphore(hw);
2368 }
2369
Cache object: f928dd7d03321e867c56070a06042f2a
|