a7c85aefe0325ea2c38f22421d262d99bad8cd24
[akaros.git] / kern / drivers / net / e1000 / e1000_api.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2008 Intel Corporation.
5
6   This program is free software; you can redistribute it and/or modify it
7   under the terms and conditions of the GNU General Public License,
8   version 2, as published by the Free Software Foundation.
9
10   This program is distributed in the hope it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13   more details.
14
15   You should have received a copy of the GNU General Public License along with
16   this program; if not, write to the Free Software Foundation, Inc.,
17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18
19   The full GNU General Public License is included in this distribution in
20   the file called "COPYING".
21
22   Contact Information:
23   Linux NICS <linux.nics@intel.com>
24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26
27 *******************************************************************************/
28
29 FILE_LICENCE(GPL2_OR_LATER);
30
31 #include "e1000_api.h"
32
33 /**
34  *  e1000_init_mac_params - Initialize MAC function pointers
35  *  @hw: pointer to the HW structure
36  *
37  *  This function initializes the function pointers for the MAC
38  *  set of functions.  Called by drivers or by e1000_setup_init_funcs.
39  **/
40 s32 e1000_init_mac_params(struct e1000_hw *hw)
41 {
42         s32 ret_val = E1000_SUCCESS;
43
44         if (hw->mac.ops.init_params) {
45                 ret_val = hw->mac.ops.init_params(hw);
46                 if (ret_val) {
47                         DEBUGOUT("MAC Initialization Error\n");
48                         goto out;
49                 }
50         } else {
51                 DEBUGOUT("mac.init_mac_params was NULL\n");
52                 ret_val = -E1000_ERR_CONFIG;
53         }
54
55 out:
56         return ret_val;
57 }
58
59 /**
60  *  e1000_init_nvm_params - Initialize NVM function pointers
61  *  @hw: pointer to the HW structure
62  *
63  *  This function initializes the function pointers for the NVM
64  *  set of functions.  Called by drivers or by e1000_setup_init_funcs.
65  **/
66 s32 e1000_init_nvm_params(struct e1000_hw * hw)
67 {
68         s32 ret_val = E1000_SUCCESS;
69
70         if (hw->nvm.ops.init_params) {
71                 ret_val = hw->nvm.ops.init_params(hw);
72                 if (ret_val) {
73                         DEBUGOUT("NVM Initialization Error\n");
74                         goto out;
75                 }
76         } else {
77                 DEBUGOUT("nvm.init_nvm_params was NULL\n");
78                 ret_val = -E1000_ERR_CONFIG;
79         }
80
81 out:
82         return ret_val;
83 }
84
85 /**
86  *  e1000_init_phy_params - Initialize PHY function pointers
87  *  @hw: pointer to the HW structure
88  *
89  *  This function initializes the function pointers for the PHY
90  *  set of functions.  Called by drivers or by e1000_setup_init_funcs.
91  **/
92 s32 e1000_init_phy_params(struct e1000_hw * hw)
93 {
94         s32 ret_val = E1000_SUCCESS;
95
96         if (hw->phy.ops.init_params) {
97                 ret_val = hw->phy.ops.init_params(hw);
98                 if (ret_val) {
99                         DEBUGOUT("PHY Initialization Error\n");
100                         goto out;
101                 }
102         } else {
103                 DEBUGOUT("phy.init_phy_params was NULL\n");
104                 ret_val = -E1000_ERR_CONFIG;
105         }
106
107 out:
108         return ret_val;
109 }
110
111 /**
112  *  e1000_set_mac_type - Sets MAC type
113  *  @hw: pointer to the HW structure
114  *
115  *  This function sets the mac type of the adapter based on the
116  *  device ID stored in the hw structure.
117  *  MUST BE FIRST FUNCTION CALLED (explicitly or through
118  *  e1000_setup_init_funcs()).
119  **/
120 s32 e1000_set_mac_type(struct e1000_hw * hw)
121 {
122         struct e1000_mac_info *mac = &hw->mac;
123         s32 ret_val = E1000_SUCCESS;
124
125         DEBUGFUNC("e1000_set_mac_type");
126
127         switch (hw->device_id) {
128                 case E1000_DEV_ID_82542:
129                         mac->type = e1000_82542;
130                         break;
131                 case E1000_DEV_ID_82543GC_FIBER:
132                 case E1000_DEV_ID_82543GC_COPPER:
133                         mac->type = e1000_82543;
134                         break;
135                 case E1000_DEV_ID_82544EI_COPPER:
136                 case E1000_DEV_ID_82544EI_FIBER:
137                 case E1000_DEV_ID_82544GC_COPPER:
138                 case E1000_DEV_ID_82544GC_LOM:
139                         mac->type = e1000_82544;
140                         break;
141                 case E1000_DEV_ID_82540EM:
142                 case E1000_DEV_ID_82540EM_LOM:
143                 case E1000_DEV_ID_82540EP:
144                 case E1000_DEV_ID_82540EP_LOM:
145                 case E1000_DEV_ID_82540EP_LP:
146                         mac->type = e1000_82540;
147                         break;
148                 case E1000_DEV_ID_82545EM_COPPER:
149                 case E1000_DEV_ID_82545EM_FIBER:
150                         mac->type = e1000_82545;
151                         break;
152                 case E1000_DEV_ID_82545GM_COPPER:
153                 case E1000_DEV_ID_82545GM_FIBER:
154                 case E1000_DEV_ID_82545GM_SERDES:
155                         mac->type = e1000_82545_rev_3;
156                         break;
157                 case E1000_DEV_ID_82546EB_COPPER:
158                 case E1000_DEV_ID_82546EB_FIBER:
159                 case E1000_DEV_ID_82546EB_QUAD_COPPER:
160                         mac->type = e1000_82546;
161                         break;
162                 case E1000_DEV_ID_82546GB_COPPER:
163                 case E1000_DEV_ID_82546GB_FIBER:
164                 case E1000_DEV_ID_82546GB_SERDES:
165                 case E1000_DEV_ID_82546GB_PCIE:
166                 case E1000_DEV_ID_82546GB_QUAD_COPPER:
167                 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
168                         mac->type = e1000_82546_rev_3;
169                         break;
170                 case E1000_DEV_ID_82541EI:
171                 case E1000_DEV_ID_82541EI_MOBILE:
172                 case E1000_DEV_ID_82541ER_LOM:
173                         mac->type = e1000_82541;
174                         break;
175                 case E1000_DEV_ID_82541ER:
176                 case E1000_DEV_ID_82541GI:
177                 case E1000_DEV_ID_82541GI_LF:
178                 case E1000_DEV_ID_82541GI_MOBILE:
179                         mac->type = e1000_82541_rev_2;
180                         break;
181                 case E1000_DEV_ID_82547EI:
182                 case E1000_DEV_ID_82547EI_MOBILE:
183                         mac->type = e1000_82547;
184                         break;
185                 case E1000_DEV_ID_82547GI:
186                         mac->type = e1000_82547_rev_2;
187                         break;
188                 default:
189                         /* Should never have loaded on this device */
190                         ret_val = -E1000_ERR_MAC_INIT;
191                         break;
192         }
193
194         return ret_val;
195 }
196
197 /**
198  *  e1000_setup_init_funcs - Initializes function pointers
199  *  @hw: pointer to the HW structure
200  *  @init_device: true will initialize the rest of the function pointers
201  *                 getting the device ready for use.  false will only set
202  *                 MAC type and the function pointers for the other init
203  *                 functions.  Passing false will not generate any hardware
204  *                 reads or writes.
205  *
206  *  This function must be called by a driver in order to use the rest
207  *  of the 'shared' code files. Called by drivers only.
208  **/
209 s32 e1000_setup_init_funcs(struct e1000_hw * hw, bool init_device)
210 {
211         s32 ret_val;
212
213         /* Can't do much good without knowing the MAC type. */
214         ret_val = e1000_set_mac_type(hw);
215         if (ret_val) {
216                 DEBUGOUT("ERROR: MAC type could not be set properly.\n");
217                 goto out;
218         }
219
220         if (!hw->hw_addr) {
221                 DEBUGOUT("ERROR: Registers not mapped\n");
222                 ret_val = -E1000_ERR_CONFIG;
223                 goto out;
224         }
225
226         /*
227          * Init function pointers to generic implementations. We do this first
228          * allowing a driver module to override it afterward.
229          */
230         e1000_init_mac_ops_generic(hw);
231         e1000_init_phy_ops_generic(hw);
232         e1000_init_nvm_ops_generic(hw);
233
234         /*
235          * Set up the init function pointers. These are functions within the
236          * adapter family file that sets up function pointers for the rest of
237          * the functions in that family.
238          */
239         switch (hw->mac.type) {
240                 case e1000_82542:
241                         e1000_init_function_pointers_82542(hw);
242                         break;
243                 case e1000_82543:
244                 case e1000_82544:
245                         e1000_init_function_pointers_82543(hw);
246                         break;
247                 case e1000_82540:
248                 case e1000_82545:
249                 case e1000_82545_rev_3:
250                 case e1000_82546:
251                 case e1000_82546_rev_3:
252                         e1000_init_function_pointers_82540(hw);
253                         break;
254                 case e1000_82541:
255                 case e1000_82541_rev_2:
256                 case e1000_82547:
257                 case e1000_82547_rev_2:
258                         e1000_init_function_pointers_82541(hw);
259                         break;
260                 default:
261                         DEBUGOUT("Hardware not supported\n");
262                         ret_val = -E1000_ERR_CONFIG;
263                         break;
264         }
265
266         /*
267          * Initialize the rest of the function pointers. These require some
268          * register reads/writes in some cases.
269          */
270         if (!(ret_val) && init_device) {
271                 ret_val = e1000_init_mac_params(hw);
272                 if (ret_val)
273                         goto out;
274
275                 ret_val = e1000_init_nvm_params(hw);
276                 if (ret_val)
277                         goto out;
278
279                 ret_val = e1000_init_phy_params(hw);
280                 if (ret_val)
281                         goto out;
282         }
283
284 out:
285         return ret_val;
286 }
287
288 /**
289  *  e1000_get_bus_info - Obtain bus information for adapter
290  *  @hw: pointer to the HW structure
291  *
292  *  This will obtain information about the HW bus for which the
293  *  adapter is attached and stores it in the hw structure. This is a
294  *  function pointer entry point called by drivers.
295  **/
296 s32 e1000_get_bus_info(struct e1000_hw * hw)
297 {
298         if (hw->mac.ops.get_bus_info)
299                 return hw->mac.ops.get_bus_info(hw);
300
301         return E1000_SUCCESS;
302 }
303
304 /**
305  *  e1000_clear_vfta - Clear VLAN filter table
306  *  @hw: pointer to the HW structure
307  *
308  *  This clears the VLAN filter table on the adapter. This is a function
309  *  pointer entry point called by drivers.
310  **/
311 void e1000_clear_vfta(struct e1000_hw *hw)
312 {
313         if (hw->mac.ops.clear_vfta)
314                 hw->mac.ops.clear_vfta(hw);
315 }
316
317 /**
318  *  e1000_write_vfta - Write value to VLAN filter table
319  *  @hw: pointer to the HW structure
320  *  @offset: the 32-bit offset in which to write the value to.
321  *  @value: the 32-bit value to write at location offset.
322  *
323  *  This writes a 32-bit value to a 32-bit offset in the VLAN filter
324  *  table. This is a function pointer entry point called by drivers.
325  **/
326 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
327 {
328         if (hw->mac.ops.write_vfta)
329                 hw->mac.ops.write_vfta(hw, offset, value);
330 }
331
332 /**
333  *  e1000_update_mc_addr_list - Update Multicast addresses
334  *  @hw: pointer to the HW structure
335  *  @mc_addr_list: array of multicast addresses to program
336  *  @mc_addr_count: number of multicast addresses to program
337  *
338  *  Updates the Multicast Table Array.
339  *  The caller must have a packed mc_addr_list of multicast addresses.
340  **/
341 void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 * mc_addr_list,
342                                                            u32 mc_addr_count)
343 {
344         if (hw->mac.ops.update_mc_addr_list)
345                 hw->mac.ops.update_mc_addr_list(hw, mc_addr_list, mc_addr_count);
346 }
347
348 /**
349  *  e1000_force_mac_fc - Force MAC flow control
350  *  @hw: pointer to the HW structure
351  *
352  *  Force the MAC's flow control settings. Currently no func pointer exists
353  *  and all implementations are handled in the generic version of this
354  *  function.
355  **/
356 s32 e1000_force_mac_fc(struct e1000_hw *hw)
357 {
358         return e1000_force_mac_fc_generic(hw);
359 }
360
361 /**
362  *  e1000_check_for_link - Check/Store link connection
363  *  @hw: pointer to the HW structure
364  *
365  *  This checks the link condition of the adapter and stores the
366  *  results in the hw->mac structure. This is a function pointer entry
367  *  point called by drivers.
368  **/
369 s32 e1000_check_for_link(struct e1000_hw * hw)
370 {
371         if (hw->mac.ops.check_for_link)
372                 return hw->mac.ops.check_for_link(hw);
373
374         return -E1000_ERR_CONFIG;
375 }
376
377 #if 0
378 /**
379  *  e1000_check_mng_mode - Check management mode
380  *  @hw: pointer to the HW structure
381  *
382  *  This checks if the adapter has manageability enabled.
383  *  This is a function pointer entry point called by drivers.
384  **/
385 bool e1000_check_mng_mode(struct e1000_hw * hw)
386 {
387         if (hw->mac.ops.check_mng_mode)
388                 return hw->mac.ops.check_mng_mode(hw);
389
390         return false;
391 }
392
393 /**
394  *  e1000_mng_write_dhcp_info - Writes DHCP info to host interface
395  *  @hw: pointer to the HW structure
396  *  @buffer: pointer to the host interface
397  *  @length: size of the buffer
398  *
399  *  Writes the DHCP information to the host interface.
400  **/
401 s32 e1000_mng_write_dhcp_info(struct e1000_hw * hw, u8 * buffer, u16 length)
402 {
403         return e1000_mng_write_dhcp_info_generic(hw, buffer, length);
404 }
405 #endif
406
407 /**
408  *  e1000_reset_hw - Reset hardware
409  *  @hw: pointer to the HW structure
410  *
411  *  This resets the hardware into a known state. This is a function pointer
412  *  entry point called by drivers.
413  **/
414 s32 e1000_reset_hw(struct e1000_hw * hw)
415 {
416         if (hw->mac.ops.reset_hw)
417                 return hw->mac.ops.reset_hw(hw);
418
419         return -E1000_ERR_CONFIG;
420 }
421
422 /**
423  *  e1000_init_hw - Initialize hardware
424  *  @hw: pointer to the HW structure
425  *
426  *  This inits the hardware readying it for operation. This is a function
427  *  pointer entry point called by drivers.
428  **/
429 s32 e1000_init_hw(struct e1000_hw * hw)
430 {
431         if (hw->mac.ops.init_hw)
432                 return hw->mac.ops.init_hw(hw);
433
434         return -E1000_ERR_CONFIG;
435 }
436
437 /**
438  *  e1000_setup_link - Configures link and flow control
439  *  @hw: pointer to the HW structure
440  *
441  *  This configures link and flow control settings for the adapter. This
442  *  is a function pointer entry point called by drivers. While modules can
443  *  also call this, they probably call their own version of this function.
444  **/
445 s32 e1000_setup_link(struct e1000_hw * hw)
446 {
447         if (hw->mac.ops.setup_link)
448                 return hw->mac.ops.setup_link(hw);
449
450         return -E1000_ERR_CONFIG;
451 }
452
453 /**
454  *  e1000_get_speed_and_duplex - Returns current speed and duplex
455  *  @hw: pointer to the HW structure
456  *  @speed: pointer to a 16-bit value to store the speed
457  *  @duplex: pointer to a 16-bit value to store the duplex.
458  *
459  *  This returns the speed and duplex of the adapter in the two 'out'
460  *  variables passed in. This is a function pointer entry point called
461  *  by drivers.
462  **/
463 s32 e1000_get_speed_and_duplex(struct e1000_hw * hw, u16 * speed, u16 * duplex)
464 {
465         if (hw->mac.ops.get_link_up_info)
466                 return hw->mac.ops.get_link_up_info(hw, speed, duplex);
467
468         return -E1000_ERR_CONFIG;
469 }
470
471 /**
472  *  e1000_setup_led - Configures SW controllable LED
473  *  @hw: pointer to the HW structure
474  *
475  *  This prepares the SW controllable LED for use and saves the current state
476  *  of the LED so it can be later restored. This is a function pointer entry
477  *  point called by drivers.
478  **/
479 s32 e1000_setup_led(struct e1000_hw * hw)
480 {
481         if (hw->mac.ops.setup_led)
482                 return hw->mac.ops.setup_led(hw);
483
484         return E1000_SUCCESS;
485 }
486
487 /**
488  *  e1000_cleanup_led - Restores SW controllable LED
489  *  @hw: pointer to the HW structure
490  *
491  *  This restores the SW controllable LED to the value saved off by
492  *  e1000_setup_led. This is a function pointer entry point called by drivers.
493  **/
494 s32 e1000_cleanup_led(struct e1000_hw * hw)
495 {
496         if (hw->mac.ops.cleanup_led)
497                 return hw->mac.ops.cleanup_led(hw);
498
499         return E1000_SUCCESS;
500 }
501
502 /**
503  *  e1000_blink_led - Blink SW controllable LED
504  *  @hw: pointer to the HW structure
505  *
506  *  This starts the adapter LED blinking. Request the LED to be setup first
507  *  and cleaned up after. This is a function pointer entry point called by
508  *  drivers.
509  **/
510 s32 e1000_blink_led(struct e1000_hw * hw)
511 {
512         if (hw->mac.ops.blink_led)
513                 return hw->mac.ops.blink_led(hw);
514
515         return E1000_SUCCESS;
516 }
517
518 /**
519  *  e1000_id_led_init - store LED configurations in SW
520  *  @hw: pointer to the HW structure
521  *
522  *  Initializes the LED config in SW. This is a function pointer entry point
523  *  called by drivers.
524  **/
525 s32 e1000_id_led_init(struct e1000_hw * hw)
526 {
527         if (hw->mac.ops.id_led_init)
528                 return hw->mac.ops.id_led_init(hw);
529
530         return E1000_SUCCESS;
531 }
532
533 /**
534  *  e1000_led_on - Turn on SW controllable LED
535  *  @hw: pointer to the HW structure
536  *
537  *  Turns the SW defined LED on. This is a function pointer entry point
538  *  called by drivers.
539  **/
540 s32 e1000_led_on(struct e1000_hw * hw)
541 {
542         if (hw->mac.ops.led_on)
543                 return hw->mac.ops.led_on(hw);
544
545         return E1000_SUCCESS;
546 }
547
548 /**
549  *  e1000_led_off - Turn off SW controllable LED
550  *  @hw: pointer to the HW structure
551  *
552  *  Turns the SW defined LED off. This is a function pointer entry point
553  *  called by drivers.
554  **/
555 s32 e1000_led_off(struct e1000_hw * hw)
556 {
557         if (hw->mac.ops.led_off)
558                 return hw->mac.ops.led_off(hw);
559
560         return E1000_SUCCESS;
561 }
562
563 /**
564  *  e1000_reset_adaptive - Reset adaptive IFS
565  *  @hw: pointer to the HW structure
566  *
567  *  Resets the adaptive IFS. Currently no func pointer exists and all
568  *  implementations are handled in the generic version of this function.
569  **/
570 void e1000_reset_adaptive(struct e1000_hw *hw)
571 {
572         e1000_reset_adaptive_generic(hw);
573 }
574
575 /**
576  *  e1000_update_adaptive - Update adaptive IFS
577  *  @hw: pointer to the HW structure
578  *
579  *  Updates adapter IFS. Currently no func pointer exists and all
580  *  implementations are handled in the generic version of this function.
581  **/
582 void e1000_update_adaptive(struct e1000_hw *hw)
583 {
584         e1000_update_adaptive_generic(hw);
585 }
586
587 /**
588  *  e1000_disable_pcie_master - Disable PCI-Express master access
589  *  @hw: pointer to the HW structure
590  *
591  *  Disables PCI-Express master access and verifies there are no pending
592  *  requests. Currently no func pointer exists and all implementations are
593  *  handled in the generic version of this function.
594  **/
595 s32 e1000_disable_pcie_master(struct e1000_hw *hw)
596 {
597         return e1000_disable_pcie_master_generic(hw);
598 }
599
600 /**
601  *  e1000_config_collision_dist - Configure collision distance
602  *  @hw: pointer to the HW structure
603  *
604  *  Configures the collision distance to the default value and is used
605  *  during link setup.
606  **/
607 void e1000_config_collision_dist(struct e1000_hw *hw)
608 {
609         if (hw->mac.ops.config_collision_dist)
610                 hw->mac.ops.config_collision_dist(hw);
611 }
612
613 /**
614  *  e1000_rar_set - Sets a receive address register
615  *  @hw: pointer to the HW structure
616  *  @addr: address to set the RAR to
617  *  @index: the RAR to set
618  *
619  *  Sets a Receive Address Register (RAR) to the specified address.
620  **/
621 void e1000_rar_set(struct e1000_hw *hw, u8 * addr, u32 index)
622 {
623         if (hw->mac.ops.rar_set)
624                 hw->mac.ops.rar_set(hw, addr, index);
625 }
626
627 /**
628  *  e1000_validate_mdi_setting - Ensures valid MDI/MDIX SW state
629  *  @hw: pointer to the HW structure
630  *
631  *  Ensures that the MDI/MDIX SW state is valid.
632  **/
633 s32 e1000_validate_mdi_setting(struct e1000_hw *hw)
634 {
635         if (hw->mac.ops.validate_mdi_setting)
636                 return hw->mac.ops.validate_mdi_setting(hw);
637
638         return E1000_SUCCESS;
639 }
640
641 /**
642  *  e1000_mta_set - Sets multicast table bit
643  *  @hw: pointer to the HW structure
644  *  @hash_value: Multicast hash value.
645  *
646  *  This sets the bit in the multicast table corresponding to the
647  *  hash value.  This is a function pointer entry point called by drivers.
648  **/
649 void e1000_mta_set(struct e1000_hw *hw, u32 hash_value)
650 {
651         if (hw->mac.ops.mta_set)
652                 hw->mac.ops.mta_set(hw, hash_value);
653 }
654
655 /**
656  *  e1000_hash_mc_addr - Determines address location in multicast table
657  *  @hw: pointer to the HW structure
658  *  @mc_addr: Multicast address to hash.
659  *
660  *  This hashes an address to determine its location in the multicast
661  *  table. Currently no func pointer exists and all implementations
662  *  are handled in the generic version of this function.
663  **/
664 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 * mc_addr)
665 {
666         return e1000_hash_mc_addr_generic(hw, mc_addr);
667 }
668
669 #if 0
670 /**
671  *  e1000_enable_tx_pkt_filtering - Enable packet filtering on TX
672  *  @hw: pointer to the HW structure
673  *
674  *  Enables packet filtering on transmit packets if manageability is enabled
675  *  and host interface is enabled.
676  *  Currently no func pointer exists and all implementations are handled in the
677  *  generic version of this function.
678  **/
679 bool e1000_enable_tx_pkt_filtering(struct e1000_hw * hw)
680 {
681         return e1000_enable_tx_pkt_filtering_generic(hw);
682 }
683
684 /**
685  *  e1000_mng_host_if_write - Writes to the manageability host interface
686  *  @hw: pointer to the HW structure
687  *  @buffer: pointer to the host interface buffer
688  *  @length: size of the buffer
689  *  @offset: location in the buffer to write to
690  *  @sum: sum of the data (not checksum)
691  *
692  *  This function writes the buffer content at the offset given on the host if.
693  *  It also does alignment considerations to do the writes in most efficient
694  *  way.  Also fills up the sum of the buffer in *buffer parameter.
695  **/
696 s32 e1000_mng_host_if_write(struct e1000_hw * hw, u8 * buffer, u16 length,
697                                                         u16 offset, u8 * sum)
698 {
699         if (hw->mac.ops.mng_host_if_write)
700                 return hw->mac.ops.mng_host_if_write(hw, buffer, length, offset, sum);
701
702         return E1000_NOT_IMPLEMENTED;
703 }
704
705 /**
706  *  e1000_mng_write_cmd_header - Writes manageability command header
707  *  @hw: pointer to the HW structure
708  *  @hdr: pointer to the host interface command header
709  *
710  *  Writes the command header after does the checksum calculation.
711  **/
712 s32 e1000_mng_write_cmd_header(struct e1000_hw * hw,
713                                                            struct e1000_host_mng_command_header * hdr)
714 {
715         if (hw->mac.ops.mng_write_cmd_header)
716                 return hw->mac.ops.mng_write_cmd_header(hw, hdr);
717
718         return E1000_NOT_IMPLEMENTED;
719 }
720
721 /**
722  *  e1000_mng_enable_host_if - Checks host interface is enabled
723  *  @hw: pointer to the HW structure
724  *
725  *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
726  *
727  *  This function checks whether the HOST IF is enabled for command operation
728  *  and also checks whether the previous command is completed.  It busy waits
729  *  in case of previous command is not completed.
730  **/
731 s32 e1000_mng_enable_host_if(struct e1000_hw * hw)
732 {
733         if (hw->mac.ops.mng_enable_host_if)
734                 return hw->mac.ops.mng_enable_host_if(hw);
735
736         return E1000_NOT_IMPLEMENTED;
737 }
738 #endif
739
740 /**
741  *  e1000_wait_autoneg - Waits for autonegotiation completion
742  *  @hw: pointer to the HW structure
743  *
744  *  Waits for autoneg to complete. Currently no func pointer exists and all
745  *  implementations are handled in the generic version of this function.
746  **/
747 s32 e1000_wait_autoneg(struct e1000_hw * hw)
748 {
749         if (hw->mac.ops.wait_autoneg)
750                 return hw->mac.ops.wait_autoneg(hw);
751
752         return E1000_SUCCESS;
753 }
754
755 /**
756  *  e1000_check_reset_block - Verifies PHY can be reset
757  *  @hw: pointer to the HW structure
758  *
759  *  Checks if the PHY is in a state that can be reset or if manageability
760  *  has it tied up. This is a function pointer entry point called by drivers.
761  **/
762 s32 e1000_check_reset_block(struct e1000_hw * hw)
763 {
764         if (hw->phy.ops.check_reset_block)
765                 return hw->phy.ops.check_reset_block(hw);
766
767         return E1000_SUCCESS;
768 }
769
770 /**
771  *  e1000_read_phy_reg - Reads PHY register
772  *  @hw: pointer to the HW structure
773  *  @offset: the register to read
774  *  @data: the buffer to store the 16-bit read.
775  *
776  *  Reads the PHY register and returns the value in data.
777  *  This is a function pointer entry point called by drivers.
778  **/
779 s32 e1000_read_phy_reg(struct e1000_hw * hw, u32 offset, u16 * data)
780 {
781         if (hw->phy.ops.read_reg)
782                 return hw->phy.ops.read_reg(hw, offset, data);
783
784         return E1000_SUCCESS;
785 }
786
787 /**
788  *  e1000_write_phy_reg - Writes PHY register
789  *  @hw: pointer to the HW structure
790  *  @offset: the register to write
791  *  @data: the value to write.
792  *
793  *  Writes the PHY register at offset with the value in data.
794  *  This is a function pointer entry point called by drivers.
795  **/
796 s32 e1000_write_phy_reg(struct e1000_hw * hw, u32 offset, u16 data)
797 {
798         if (hw->phy.ops.write_reg)
799                 return hw->phy.ops.write_reg(hw, offset, data);
800
801         return E1000_SUCCESS;
802 }
803
804 /**
805  *  e1000_release_phy - Generic release PHY
806  *  @hw: pointer to the HW structure
807  *
808  *  Return if silicon family does not require a semaphore when accessing the
809  *  PHY.
810  **/
811 void e1000_release_phy(struct e1000_hw *hw)
812 {
813         if (hw->phy.ops.release)
814                 hw->phy.ops.release(hw);
815 }
816
817 /**
818  *  e1000_acquire_phy - Generic acquire PHY
819  *  @hw: pointer to the HW structure
820  *
821  *  Return success if silicon family does not require a semaphore when
822  *  accessing the PHY.
823  **/
824 s32 e1000_acquire_phy(struct e1000_hw *hw)
825 {
826         if (hw->phy.ops.acquire)
827                 return hw->phy.ops.acquire(hw);
828
829         return E1000_SUCCESS;
830 }
831
832 /**
833  *  e1000_read_kmrn_reg - Reads register using Kumeran interface
834  *  @hw: pointer to the HW structure
835  *  @offset: the register to read
836  *  @data: the location to store the 16-bit value read.
837  *
838  *  Reads a register out of the Kumeran interface. Currently no func pointer
839  *  exists and all implementations are handled in the generic version of
840  *  this function.
841  **/
842 s32 e1000_read_kmrn_reg(struct e1000_hw * hw, u32 offset, u16 * data)
843 {
844         return e1000_read_kmrn_reg_generic(hw, offset, data);
845 }
846
847 /**
848  *  e1000_write_kmrn_reg - Writes register using Kumeran interface
849  *  @hw: pointer to the HW structure
850  *  @offset: the register to write
851  *  @data: the value to write.
852  *
853  *  Writes a register to the Kumeran interface. Currently no func pointer
854  *  exists and all implementations are handled in the generic version of
855  *  this function.
856  **/
857 s32 e1000_write_kmrn_reg(struct e1000_hw * hw, u32 offset, u16 data)
858 {
859         return e1000_write_kmrn_reg_generic(hw, offset, data);
860 }
861
862 #if 0
863 /**
864  *  e1000_get_cable_length - Retrieves cable length estimation
865  *  @hw: pointer to the HW structure
866  *
867  *  This function estimates the cable length and stores them in
868  *  hw->phy.min_length and hw->phy.max_length. This is a function pointer
869  *  entry point called by drivers.
870  **/
871 s32 e1000_get_cable_length(struct e1000_hw * hw)
872 {
873         if (hw->phy.ops.get_cable_length)
874                 return hw->phy.ops.get_cable_length(hw);
875
876         return E1000_SUCCESS;
877 }
878 #endif
879
880 /**
881  *  e1000_get_phy_info - Retrieves PHY information from registers
882  *  @hw: pointer to the HW structure
883  *
884  *  This function gets some information from various PHY registers and
885  *  populates hw->phy values with it. This is a function pointer entry
886  *  point called by drivers.
887  **/
888 s32 e1000_get_phy_info(struct e1000_hw * hw)
889 {
890         if (hw->phy.ops.get_info)
891                 return hw->phy.ops.get_info(hw);
892
893         return E1000_SUCCESS;
894 }
895
896 /**
897  *  e1000_phy_hw_reset - Hard PHY reset
898  *  @hw: pointer to the HW structure
899  *
900  *  Performs a hard PHY reset. This is a function pointer entry point called
901  *  by drivers.
902  **/
903 s32 e1000_phy_hw_reset(struct e1000_hw * hw)
904 {
905         if (hw->phy.ops.reset)
906                 return hw->phy.ops.reset(hw);
907
908         return E1000_SUCCESS;
909 }
910
911 /**
912  *  e1000_phy_commit - Soft PHY reset
913  *  @hw: pointer to the HW structure
914  *
915  *  Performs a soft PHY reset on those that apply. This is a function pointer
916  *  entry point called by drivers.
917  **/
918 s32 e1000_phy_commit(struct e1000_hw * hw)
919 {
920         if (hw->phy.ops.commit)
921                 return hw->phy.ops.commit(hw);
922
923         return E1000_SUCCESS;
924 }
925
926 /**
927  *  e1000_set_d0_lplu_state - Sets low power link up state for D0
928  *  @hw: pointer to the HW structure
929  *  @active: boolean used to enable/disable lplu
930  *
931  *  Success returns 0, Failure returns 1
932  *
933  *  The low power link up (lplu) state is set to the power management level D0
934  *  and SmartSpeed is disabled when active is true, else clear lplu for D0
935  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
936  *  is used during Dx states where the power conservation is most important.
937  *  During driver activity, SmartSpeed should be enabled so performance is
938  *  maintained.  This is a function pointer entry point called by drivers.
939  **/
940 s32 e1000_set_d0_lplu_state(struct e1000_hw * hw, bool active)
941 {
942         if (hw->phy.ops.set_d0_lplu_state)
943                 return hw->phy.ops.set_d0_lplu_state(hw, active);
944
945         return E1000_SUCCESS;
946 }
947
948 /**
949  *  e1000_set_d3_lplu_state - Sets low power link up state for D3
950  *  @hw: pointer to the HW structure
951  *  @active: boolean used to enable/disable lplu
952  *
953  *  Success returns 0, Failure returns 1
954  *
955  *  The low power link up (lplu) state is set to the power management level D3
956  *  and SmartSpeed is disabled when active is true, else clear lplu for D3
957  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
958  *  is used during Dx states where the power conservation is most important.
959  *  During driver activity, SmartSpeed should be enabled so performance is
960  *  maintained.  This is a function pointer entry point called by drivers.
961  **/
962 s32 e1000_set_d3_lplu_state(struct e1000_hw * hw, bool active)
963 {
964         if (hw->phy.ops.set_d3_lplu_state)
965                 return hw->phy.ops.set_d3_lplu_state(hw, active);
966
967         return E1000_SUCCESS;
968 }
969
970 /**
971  *  e1000_read_mac_addr - Reads MAC address
972  *  @hw: pointer to the HW structure
973  *
974  *  Reads the MAC address out of the adapter and stores it in the HW structure.
975  *  Currently no func pointer exists and all implementations are handled in the
976  *  generic version of this function.
977  **/
978 s32 e1000_read_mac_addr(struct e1000_hw * hw)
979 {
980         if (hw->mac.ops.read_mac_addr)
981                 return hw->mac.ops.read_mac_addr(hw);
982
983         return e1000_read_mac_addr_generic(hw);
984 }
985
986 /**
987  *  e1000_read_pba_num - Read device part number
988  *  @hw: pointer to the HW structure
989  *  @pba_num: pointer to device part number
990  *
991  *  Reads the product board assembly (PBA) number from the EEPROM and stores
992  *  the value in pba_num.
993  *  Currently no func pointer exists and all implementations are handled in the
994  *  generic version of this function.
995  **/
996 s32 e1000_read_pba_num(struct e1000_hw * hw, u32 * pba_num)
997 {
998         return e1000_read_pba_num_generic(hw, pba_num);
999 }
1000
1001 /**
1002  *  e1000_validate_nvm_checksum - Verifies NVM (EEPROM) checksum
1003  *  @hw: pointer to the HW structure
1004  *
1005  *  Validates the NVM checksum is correct. This is a function pointer entry
1006  *  point called by drivers.
1007  **/
1008 s32 e1000_validate_nvm_checksum(struct e1000_hw * hw)
1009 {
1010         if (hw->nvm.ops.validate)
1011                 return hw->nvm.ops.validate(hw);
1012
1013         return -E1000_ERR_CONFIG;
1014 }
1015
1016 /**
1017  *  e1000_update_nvm_checksum - Updates NVM (EEPROM) checksum
1018  *  @hw: pointer to the HW structure
1019  *
1020  *  Updates the NVM checksum. Currently no func pointer exists and all
1021  *  implementations are handled in the generic version of this function.
1022  **/
1023 s32 e1000_update_nvm_checksum(struct e1000_hw * hw)
1024 {
1025         if (hw->nvm.ops.update)
1026                 return hw->nvm.ops.update(hw);
1027
1028         return -E1000_ERR_CONFIG;
1029 }
1030
1031 /**
1032  *  e1000_reload_nvm - Reloads EEPROM
1033  *  @hw: pointer to the HW structure
1034  *
1035  *  Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the
1036  *  extended control register.
1037  **/
1038 void e1000_reload_nvm(struct e1000_hw *hw)
1039 {
1040         if (hw->nvm.ops.reload)
1041                 hw->nvm.ops.reload(hw);
1042 }
1043
1044 /**
1045  *  e1000_read_nvm - Reads NVM (EEPROM)
1046  *  @hw: pointer to the HW structure
1047  *  @offset: the word offset to read
1048  *  @words: number of 16-bit words to read
1049  *  @data: pointer to the properly sized buffer for the data.
1050  *
1051  *  Reads 16-bit chunks of data from the NVM (EEPROM). This is a function
1052  *  pointer entry point called by drivers.
1053  **/
1054 s32 e1000_read_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 * data)
1055 {
1056         if (hw->nvm.ops.read)
1057                 return hw->nvm.ops.read(hw, offset, words, data);
1058
1059         return -E1000_ERR_CONFIG;
1060 }
1061
1062 /**
1063  *  e1000_write_nvm - Writes to NVM (EEPROM)
1064  *  @hw: pointer to the HW structure
1065  *  @offset: the word offset to read
1066  *  @words: number of 16-bit words to write
1067  *  @data: pointer to the properly sized buffer for the data.
1068  *
1069  *  Writes 16-bit chunks of data to the NVM (EEPROM). This is a function
1070  *  pointer entry point called by drivers.
1071  **/
1072 s32 e1000_write_nvm(struct e1000_hw * hw, u16 offset, u16 words, u16 * data)
1073 {
1074         if (hw->nvm.ops.write)
1075                 return hw->nvm.ops.write(hw, offset, words, data);
1076
1077         return E1000_SUCCESS;
1078 }
1079
1080 /**
1081  * e1000_power_up_phy - Restores link in case of PHY power down
1082  * @hw: pointer to the HW structure
1083  *
1084  * The phy may be powered down to save power, to turn off link when the
1085  * driver is unloaded, or wake on lan is not enabled (among others).
1086  **/
1087 void e1000_power_up_phy(struct e1000_hw *hw)
1088 {
1089         if (hw->phy.ops.power_up)
1090                 hw->phy.ops.power_up(hw);
1091
1092         e1000_setup_link(hw);
1093 }
1094
1095 /**
1096  * e1000_power_down_phy - Power down PHY
1097  * @hw: pointer to the HW structure
1098  *
1099  * The phy may be powered down to save power, to turn off link when the
1100  * driver is unloaded, or wake on lan is not enabled (among others).
1101  **/
1102 void e1000_power_down_phy(struct e1000_hw *hw)
1103 {
1104         if (hw->phy.ops.power_down)
1105                 hw->phy.ops.power_down(hw);
1106 }