Start to get e1000 into a shape we can use
authorRonald G. Minnich <rminnich@google.com>
Sun, 26 Jan 2014 22:15:12 +0000 (14:15 -0800)
committerRonald G. Minnich <rminnich@google.com>
Sun, 26 Jan 2014 22:15:12 +0000 (14:15 -0800)
It's not as bad as it looks. I've got to bail for a bit, but I suggest
we get the mac, then nvm code to build, then see which model we want to
support.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
16 files changed:
kern/drivers/net/Kbuild
kern/drivers/net/e1000/e1000.h
kern/drivers/net/e1000/e1000_api.h
kern/drivers/net/e1000/e1000_defines.h
kern/drivers/net/e1000/e1000_hw.h
kern/drivers/net/e1000/e1000_mac.c
kern/drivers/net/e1000/e1000_mac.h
kern/drivers/net/e1000/e1000_nvm.h
kern/drivers/net/e1000/e1000_osdep.h
kern/drivers/net/e1000/e1000_phy.c
kern/drivers/net/e1000/e1000_phy.h
kern/drivers/net/e1000/e1000_regs.h
kern/drivers/net/r8169.c
scripts/etherboot/PATCH
scripts/etherboot/func.cocci
scripts/etherboot/scalar.cocci

index 8d9cd1d..7f3b018 100644 (file)
@@ -3,5 +3,4 @@ obj-y                                                   += dummy.o
 obj-y                                                  += ether8139.o
 obj-y                                                  += mii.o
 obj-y                                                  += r8169.o
-# here's how to do conditional builds:
-#obj-$(CONFIG_E1000)                   += e1000.o
+obj-y                                                  += e1000/
index 31dbb85..d142da9 100644 (file)
@@ -26,7 +26,6 @@
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_ONLY );
 
 /* Linux PRO/1000 Ethernet Driver main header file */
 
@@ -103,8 +102,8 @@ struct e1000_buffer {
        struct sk_buff *skb;
        dma_addr_t dma;
        unsigned long time_stamp;
-       u16 length;
-       u16 next_to_watch;
+       uint16_t length;
+       uint16_t next_to_watch;
 };
 
 struct e1000_rx_buffer {
@@ -132,8 +131,8 @@ struct e1000_tx_ring {
        struct e1000_buffer *buffer_info;
 
        spinlock_t tx_lock;
-       u16 tdh;
-       u16 tdt;
+       uint16_t tdh;
+       uint16_t tdt;
 
        /* TXDdescriptor index increment to be used when advancing
        * to the next descriptor. This is normally one, but on some
@@ -167,8 +166,8 @@ struct e1000_rx_ring {
        /* cpu for rx queue */
        int cpu;
 
-       u16 rdh;
-       u16 rdt;
+       uint16_t rdh;
+       uint16_t rdt;
 };
 
 
@@ -193,23 +192,23 @@ struct e1000_rx_ring {
 /* board specific private data structure */
 
 struct e1000_adapter {
-       u32 bd_number;
-       u32 rx_buffer_len;
-       u32 wol;
-       u32 smartspeed;
-       u32 en_mng_pt;
-       u16 link_speed;
-       u16 link_duplex;
+       uint32_t bd_number;
+       uint32_t rx_buffer_len;
+       uint32_t wol;
+       uint32_t smartspeed;
+       uint32_t en_mng_pt;
+       uint16_t link_speed;
+       uint16_t link_duplex;
        spinlock_t stats_lock;
        unsigned int total_tx_bytes;
        unsigned int total_tx_packets;
        unsigned int total_rx_bytes;
        unsigned int total_rx_packets;
        /* Interrupt Throttle Rate */
-       u32 itr;
-       u32 itr_setting;
-       u16 tx_itr;
-       u16 rx_itr;
+       uint32_t itr;
+       uint32_t itr_setting;
+       uint16_t tx_itr;
+       uint16_t rx_itr;
 
        bool fc_autoneg;
 
@@ -217,18 +216,18 @@ struct e1000_adapter {
        struct e1000_tx_ring *tx_ring;
        unsigned int restart_queue;
        unsigned long tx_queue_len;
-       u32 txd_cmd;
-       u32 tx_int_delay;
-       u32 tx_abs_int_delay;
-       u32 gotc;
+       uint32_t txd_cmd;
+       uint32_t tx_int_delay;
+       uint32_t tx_abs_int_delay;
+       uint32_t gotc;
        u64 gotc_old;
        u64 tpt_old;
        u64 colc_old;
-       u32 tx_timeout_count;
-       u32 tx_fifo_head;
-       u32 tx_head_addr;
-       u32 tx_fifo_size;
-       u8 tx_timeout_factor;
+       uint32_t tx_timeout_count;
+       uint32_t tx_fifo_head;
+       uint32_t tx_head_addr;
+       uint32_t tx_fifo_size;
+       uint8_t tx_timeout_factor;
        bool pcix_82544;
        bool detect_tx_hung;
 
@@ -242,14 +241,14 @@ struct e1000_adapter {
 
        u64 hw_csum_err;
        u64 hw_csum_good;
-       u32 alloc_rx_buff_failed;
-       u32 rx_int_delay;
-       u32 rx_abs_int_delay;
+       uint32_t alloc_rx_buff_failed;
+       uint32_t rx_int_delay;
+       uint32_t rx_abs_int_delay;
        bool rx_csum;
-       u32 gorc;
+       uint32_t gorc;
        u64 gorc_old;
-       u32 max_frame_size;
-       u32 min_frame_size;
+       uint32_t max_frame_size;
+       uint32_t min_frame_size;
 
 
        /* OS defined structs */
@@ -266,15 +265,15 @@ struct e1000_adapter {
        int msg_enable;
        /* to not mess up cache alignment, always add to the bottom */
        unsigned long state;
-       u32 eeprom_wol;
+       uint32_t eeprom_wol;
 
-       u32 *config_space;
+       uint32_t *config_space;
 
        /* hardware capability, feature, and workaround flags */
        unsigned int flags;
 
        /* upper limit parameter for tx desc size */
-       u32 tx_desc_pwr;
+       uint32_t tx_desc_pwr;
 
 #define NUM_TX_DESC    8
 #define NUM_RX_DESC    8
@@ -316,7 +315,7 @@ extern int e1000_up(struct e1000_adapter *adapter);
 extern void e1000_down(struct e1000_adapter *adapter);
 extern void e1000_reinit_locked(struct e1000_adapter *adapter);
 extern void e1000_reset(struct e1000_adapter *adapter);
-extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx);
+extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
 extern int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
 extern int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
 extern void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
index d9f13bf..1767730 100644 (file)
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
-
 #ifndef _E1000_API_H_
 #define _E1000_API_H_
 
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <gpxe/io.h>
-#include <errno.h>
-#include <byteswap.h>
-#include <gpxe/pci.h>
-#include <gpxe/malloc.h>
-#include <gpxe/if_ether.h>
-#include <gpxe/ethernet.h>
-#include <gpxe/iobuf.h>
-#include <gpxe/netdevice.h>
-
 #include "e1000_hw.h"
 
 extern void    e1000_init_function_pointers_82542(struct e1000_hw *hw) __attribute__((weak));
@@ -53,76 +36,78 @@ extern void    e1000_init_function_pointers_82543(struct e1000_hw *hw) __attribu
 extern void    e1000_init_function_pointers_82540(struct e1000_hw *hw) __attribute__((weak));
 extern void    e1000_init_function_pointers_82541(struct e1000_hw *hw) __attribute__((weak));
 
-s32  e1000_set_mac_type(struct e1000_hw *hw);
-s32  e1000_setup_init_funcs(struct e1000_hw *hw, bool init_device);
-s32  e1000_init_mac_params(struct e1000_hw *hw);
-s32  e1000_init_nvm_params(struct e1000_hw *hw);
-s32  e1000_init_phy_params(struct e1000_hw *hw);
-s32  e1000_get_bus_info(struct e1000_hw *hw);
+int32_t  e1000_set_mac_type(struct e1000_hw *hw);
+int32_t  e1000_setup_init_funcs(struct e1000_hw *hw, bool init_device);
+int32_t  e1000_init_mac_params(struct e1000_hw *hw);
+int32_t  e1000_init_nvm_params(struct e1000_hw *hw);
+int32_t  e1000_init_phy_params(struct e1000_hw *hw);
+int32_t  e1000_get_bus_info(struct e1000_hw *hw);
 void e1000_clear_vfta(struct e1000_hw *hw);
-void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value);
-s32  e1000_force_mac_fc(struct e1000_hw *hw);
-s32  e1000_check_for_link(struct e1000_hw *hw);
-s32  e1000_reset_hw(struct e1000_hw *hw);
-s32  e1000_init_hw(struct e1000_hw *hw);
-s32  e1000_setup_link(struct e1000_hw *hw);
-s32  e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed,
-                                u16 *duplex);
-s32  e1000_disable_pcie_master(struct e1000_hw *hw);
+void e1000_write_vfta(struct e1000_hw *hw, uint32_t offset, uint32_t value);
+int32_t  e1000_force_mac_fc(struct e1000_hw *hw);
+int32_t  e1000_check_for_link(struct e1000_hw *hw);
+int32_t  e1000_reset_hw(struct e1000_hw *hw);
+int32_t  e1000_init_hw(struct e1000_hw *hw);
+int32_t  e1000_setup_link(struct e1000_hw *hw);
+int32_t  e1000_get_speed_and_duplex(struct e1000_hw *hw, uint16_t *speed,
+                                uint16_t *duplex);
+int32_t  e1000_disable_pcie_master(struct e1000_hw *hw);
 void e1000_config_collision_dist(struct e1000_hw *hw);
-void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index);
-void e1000_mta_set(struct e1000_hw *hw, u32 hash_value);
-u32  e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr);
+void e1000_rar_set(struct e1000_hw *hw, uint8_t *addr, uint32_t index);
+void e1000_mta_set(struct e1000_hw *hw, uint32_t hash_value);
+uint32_t  e1000_hash_mc_addr(struct e1000_hw *hw, uint8_t *mc_addr);
 void e1000_update_mc_addr_list(struct e1000_hw *hw,
-                               u8 *mc_addr_list, u32 mc_addr_count);
-s32  e1000_setup_led(struct e1000_hw *hw);
-s32  e1000_cleanup_led(struct e1000_hw *hw);
-s32  e1000_check_reset_block(struct e1000_hw *hw);
-s32  e1000_blink_led(struct e1000_hw *hw);
-s32  e1000_led_on(struct e1000_hw *hw);
-s32  e1000_led_off(struct e1000_hw *hw);
-s32 e1000_id_led_init(struct e1000_hw *hw);
+                               uint8_t *mc_addr_list, uint32_t mc_addr_count);
+int32_t  e1000_setup_led(struct e1000_hw *hw);
+int32_t  e1000_cleanup_led(struct e1000_hw *hw);
+int32_t  e1000_check_reset_block(struct e1000_hw *hw);
+int32_t  e1000_blink_led(struct e1000_hw *hw);
+int32_t  e1000_led_on(struct e1000_hw *hw);
+int32_t  e1000_led_off(struct e1000_hw *hw);
+int32_t e1000_id_led_init(struct e1000_hw *hw);
 void e1000_reset_adaptive(struct e1000_hw *hw);
 void e1000_update_adaptive(struct e1000_hw *hw);
 #if 0
 s32  e1000_get_cable_length(struct e1000_hw *hw);
 #endif
-s32  e1000_validate_mdi_setting(struct e1000_hw *hw);
-s32  e1000_read_phy_reg(struct e1000_hw *hw, u32 offset, u16 *data);
-s32  e1000_write_phy_reg(struct e1000_hw *hw, u32 offset, u16 data);
-s32  e1000_get_phy_info(struct e1000_hw *hw);
+int32_t  e1000_validate_mdi_setting(struct e1000_hw *hw);
+int32_t  e1000_read_phy_reg(struct e1000_hw *hw, uint32_t offset, uint16_t *data);
+int32_t  e1000_write_phy_reg(struct e1000_hw *hw, uint32_t offset, uint16_t data);
+int32_t  e1000_get_phy_info(struct e1000_hw *hw);
 void e1000_release_phy(struct e1000_hw *hw);
-s32  e1000_acquire_phy(struct e1000_hw *hw);
-s32  e1000_phy_hw_reset(struct e1000_hw *hw);
-s32  e1000_phy_commit(struct e1000_hw *hw);
+int32_t  e1000_acquire_phy(struct e1000_hw *hw);
+int32_t  e1000_phy_hw_reset(struct e1000_hw *hw);
+int32_t  e1000_phy_commit(struct e1000_hw *hw);
 void e1000_power_up_phy(struct e1000_hw *hw);
 void e1000_power_down_phy(struct e1000_hw *hw);
-s32  e1000_read_mac_addr(struct e1000_hw *hw);
-s32  e1000_read_pba_num(struct e1000_hw *hw, u32 *part_num);
+int32_t  e1000_read_mac_addr(struct e1000_hw *hw);
+int32_t  e1000_read_pba_num(struct e1000_hw *hw, uint32_t *part_num);
 void e1000_reload_nvm(struct e1000_hw *hw);
-s32  e1000_update_nvm_checksum(struct e1000_hw *hw);
-s32  e1000_validate_nvm_checksum(struct e1000_hw *hw);
-s32  e1000_read_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data);
-s32  e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data);
-s32  e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data);
-s32  e1000_write_nvm(struct e1000_hw *hw, u16 offset, u16 words,
-                     u16 *data);
-s32  e1000_wait_autoneg(struct e1000_hw *hw);
-s32  e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active);
-s32  e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active);
+int32_t  e1000_update_nvm_checksum(struct e1000_hw *hw);
+int32_t  e1000_validate_nvm_checksum(struct e1000_hw *hw);
+int32_t  e1000_read_nvm(struct e1000_hw *hw, uint16_t offset, uint16_t words,
+                   uint16_t *data);
+int32_t  e1000_read_kmrn_reg(struct e1000_hw *hw, uint32_t offset, uint16_t *data);
+int32_t  e1000_write_kmrn_reg(struct e1000_hw *hw, uint32_t offset, uint16_t data);
+int32_t  e1000_write_nvm(struct e1000_hw *hw, uint16_t offset, uint16_t words,
+                     uint16_t *data);
+int32_t  e1000_wait_autoneg(struct e1000_hw *hw);
+int32_t  e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active);
+int32_t  e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active);
 bool e1000_check_mng_mode(struct e1000_hw *hw);
 bool e1000_enable_tx_pkt_filtering(struct e1000_hw *hw);
-s32  e1000_mng_enable_host_if(struct e1000_hw *hw);
-s32  e1000_mng_host_if_write(struct e1000_hw *hw,
-                             u8 *buffer, u16 length, u16 offset, u8 *sum);
-s32  e1000_mng_write_cmd_header(struct e1000_hw *hw,
+int32_t  e1000_mng_enable_host_if(struct e1000_hw *hw);
+int32_t  e1000_mng_host_if_write(struct e1000_hw *hw,
+                             uint8_t *buffer, uint16_t length, uint16_t offset,
+                            uint8_t *sum);
+int32_t  e1000_mng_write_cmd_header(struct e1000_hw *hw,
                                 struct e1000_host_mng_command_header *hdr);
-s32  e1000_mng_write_dhcp_info(struct e1000_hw * hw,
-                                    u8 *buffer, u16 length);
-u32  e1000_translate_register_82542(u32 reg) __attribute__((weak));
+int32_t  e1000_mng_write_dhcp_info(struct e1000_hw * hw,
+                                    uint8_t *buffer, uint16_t length);
+uint32_t  e1000_translate_register_82542(uint32_t reg) __attribute__((weak));
 
-extern int e1000_probe(struct pci_device *pdev,
-                      const struct pci_device_id *id __unused);
+//extern int e1000_probe(struct pci_device *pdev,
+//                    const struct pci_device_id *id );
 extern void e1000_remove(struct pci_device *pdev);
 
 #endif
index c585f09..91ec63d 100644 (file)
@@ -26,7 +26,6 @@
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
 
 #ifndef _E1000_DEFINES_H_
 #define _E1000_DEFINES_H_
index 753f75e..5f83e0f 100644 (file)
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
-
 #ifndef _E1000_HW_H_
 #define _E1000_HW_H_
 
-#include "e1000_osdep.h"
-#include "e1000_regs.h"
+#include <vfs.h>
+#include <kfs.h>
+#include <slab.h>
+#include <kmalloc.h>
+#include <kref.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <error.h>
+#include <cpio.h>
+#include <pmap.h>
+#include <smp.h>
+#include <ip.h>
 #include "e1000_defines.h"
 
 struct e1000_hw;
@@ -224,35 +233,35 @@ enum e1000_serdes_link_state {
 
 /* Receive Descriptor */
 struct e1000_rx_desc {
-       __le64 buffer_addr; /* Address of the descriptor's data buffer */
-       __le16 length;      /* Length of data DMAed into data buffer */
-       __le16 csum;        /* Packet checksum */
-       u8  status;         /* Descriptor status */
-       u8  errors;         /* Descriptor Errors */
-       __le16 special;
+       uint64_t buffer_addr; /* Address of the descriptor's data buffer */
+       uint16_t length;      /* Length of data DMAed into data buffer */
+       uint16_t csum;        /* Packet checksum */
+       uint8_t  status;         /* Descriptor status */
+       uint8_t  errors;         /* Descriptor Errors */
+       uint16_t special;
 };
 
 /* Receive Descriptor - Extended */
 union e1000_rx_desc_extended {
        struct {
-               __le64 buffer_addr;
-               __le64 reserved;
+               uint64_t buffer_addr;
+               uint64_t reserved;
        } read;
        struct {
                struct {
-                       __le32 mrq;           /* Multiple Rx Queues */
+                       uint32_t mrq;           /* Multiple Rx Queues */
                        union {
-                               __le32 rss;         /* RSS Hash */
+                               uint32_t rss;         /* RSS Hash */
                                struct {
-                                       __le16 ip_id;  /* IP id */
-                                       __le16 csum;   /* Packet Checksum */
+                                       uint16_t ip_id;  /* IP id */
+                                       uint16_t csum;   /* Packet Checksum */
                                } csum_ip;
                        } hi_dword;
                } lower;
                struct {
-                       __le32 status_error;  /* ext status/error */
-                       __le16 length;
-                       __le16 vlan;          /* VLAN tag */
+                       uint32_t status_error;  /* ext status/error */
+                       uint16_t length;
+                       uint16_t vlan;          /* VLAN tag */
                } upper;
        } wb;  /* writeback */
 };
@@ -262,49 +271,49 @@ union e1000_rx_desc_extended {
 union e1000_rx_desc_packet_split {
        struct {
                /* one buffer for protocol header(s), three data buffers */
-               __le64 buffer_addr[MAX_PS_BUFFERS];
+               uint64_t buffer_addr[MAX_PS_BUFFERS];
        } read;
        struct {
                struct {
-                       __le32 mrq;           /* Multiple Rx Queues */
+                       uint32_t mrq;           /* Multiple Rx Queues */
                        union {
-                               __le32 rss;           /* RSS Hash */
+                               uint32_t rss;           /* RSS Hash */
                                struct {
-                                       __le16 ip_id;    /* IP id */
-                                       __le16 csum;     /* Packet Checksum */
+                                       uint16_t ip_id;    /* IP id */
+                                       uint16_t csum;     /* Packet Checksum */
                                } csum_ip;
                        } hi_dword;
                } lower;
                struct {
-                       __le32 status_error;  /* ext status/error */
-                       __le16 length0;       /* length of buffer 0 */
-                       __le16 vlan;          /* VLAN tag */
+                       uint32_t status_error;  /* ext status/error */
+                       uint16_t length0;       /* length of buffer 0 */
+                       uint16_t vlan;          /* VLAN tag */
                } middle;
                struct {
-                       __le16 header_status;
-                       __le16 length[3];     /* length of buffers 1-3 */
+                       uint16_t header_status;
+                       uint16_t length[3];     /* length of buffers 1-3 */
                } upper;
-               __le64 reserved;
+               uint64_t reserved;
        } wb; /* writeback */
 };
 
 /* Transmit Descriptor */
 struct e1000_tx_desc {
-       __le64 buffer_addr;   /* Address of the descriptor's data buffer */
+       uint64_t buffer_addr;   /* Address of the descriptor's data buffer */
        union {
-               __le32 data;
+               uint32_t data;
                struct {
-                       __le16 length;    /* Data buffer length */
-                       u8 cso;           /* Checksum offset */
-                       u8 cmd;           /* Descriptor control */
+                       uint16_t length;    /* Data buffer length */
+                       uint8_t cso;           /* Checksum offset */
+                       uint8_t cmd;           /* Descriptor control */
                } flags;
        } lower;
        union {
-               __le32 data;
+               uint32_t data;
                struct {
-                       u8 status;        /* Descriptor status */
-                       u8 css;           /* Checksum start */
-                       __le16 special;
+                       uint8_t status;        /* Descriptor status */
+                       uint8_t css;           /* Checksum start */
+                       uint16_t special;
                } fields;
        } upper;
 };
@@ -312,282 +321,293 @@ struct e1000_tx_desc {
 /* Offload Context Descriptor */
 struct e1000_context_desc {
        union {
-               __le32 ip_config;
+               uint32_t ip_config;
                struct {
-                       u8 ipcss;         /* IP checksum start */
-                       u8 ipcso;         /* IP checksum offset */
-                       __le16 ipcse;     /* IP checksum end */
+                       uint8_t ipcss;         /* IP checksum start */
+                       uint8_t ipcso;         /* IP checksum offset */
+                       uint16_t ipcse;     /* IP checksum end */
                } ip_fields;
        } lower_setup;
        union {
-               __le32 tcp_config;
+               uint32_t tcp_config;
                struct {
-                       u8 tucss;         /* TCP checksum start */
-                       u8 tucso;         /* TCP checksum offset */
-                       __le16 tucse;     /* TCP checksum end */
+                       uint8_t tucss;         /* TCP checksum start */
+                       uint8_t tucso;         /* TCP checksum offset */
+                       uint16_t tucse;     /* TCP checksum end */
                } tcp_fields;
        } upper_setup;
-       __le32 cmd_and_length;
+       uint32_t cmd_and_length;
        union {
-               __le32 data;
+               uint32_t data;
                struct {
-                       u8 status;        /* Descriptor status */
-                       u8 hdr_len;       /* Header length */
-                       __le16 mss;       /* Maximum segment size */
+                       uint8_t status;        /* Descriptor status */
+                       uint8_t hdr_len;       /* Header length */
+                       uint16_t mss;       /* Maximum segment size */
                } fields;
        } tcp_seg_setup;
 };
 
 /* Offload data descriptor */
 struct e1000_data_desc {
-       __le64 buffer_addr;   /* Address of the descriptor's buffer address */
+       uint64_t buffer_addr;   /* Address of the descriptor's buffer address */
        union {
-               __le32 data;
+               uint32_t data;
                struct {
-                       __le16 length;    /* Data buffer length */
-                       u8 typ_len_ext;
-                       u8 cmd;
+                       uint16_t length;    /* Data buffer length */
+                       uint8_t typ_len_ext;
+                       uint8_t cmd;
                } flags;
        } lower;
        union {
-               __le32 data;
+               uint32_t data;
                struct {
-                       u8 status;        /* Descriptor status */
-                       u8 popts;         /* Packet Options */
-                       __le16 special;
+                       uint8_t status;        /* Descriptor status */
+                       uint8_t popts;         /* Packet Options */
+                       uint16_t special;
                } fields;
        } upper;
 };
 
 /* Statistics counters collected by the MAC */
 struct e1000_hw_stats {
-       u64 crcerrs;
-       u64 algnerrc;
-       u64 symerrs;
-       u64 rxerrc;
-       u64 mpc;
-       u64 scc;
-       u64 ecol;
-       u64 mcc;
-       u64 latecol;
-       u64 colc;
-       u64 dc;
-       u64 tncrs;
-       u64 sec;
-       u64 cexterr;
-       u64 rlec;
-       u64 xonrxc;
-       u64 xontxc;
-       u64 xoffrxc;
-       u64 xofftxc;
-       u64 fcruc;
-       u64 prc64;
-       u64 prc127;
-       u64 prc255;
-       u64 prc511;
-       u64 prc1023;
-       u64 prc1522;
-       u64 gprc;
-       u64 bprc;
-       u64 mprc;
-       u64 gptc;
-       u64 gorc;
-       u64 gotc;
-       u64 rnbc;
-       u64 ruc;
-       u64 rfc;
-       u64 roc;
-       u64 rjc;
-       u64 mgprc;
-       u64 mgpdc;
-       u64 mgptc;
-       u64 tor;
-       u64 tot;
-       u64 tpr;
-       u64 tpt;
-       u64 ptc64;
-       u64 ptc127;
-       u64 ptc255;
-       u64 ptc511;
-       u64 ptc1023;
-       u64 ptc1522;
-       u64 mptc;
-       u64 bptc;
-       u64 tsctc;
-       u64 tsctfc;
-       u64 iac;
-       u64 icrxptc;
-       u64 icrxatc;
-       u64 ictxptc;
-       u64 ictxatc;
-       u64 ictxqec;
-       u64 ictxqmtc;
-       u64 icrxdmtc;
-       u64 icrxoc;
-       u64 cbtmpc;
-       u64 htdpmc;
-       u64 cbrdpc;
-       u64 cbrmpc;
-       u64 rpthc;
-       u64 hgptc;
-       u64 htcbdpc;
-       u64 hgorc;
-       u64 hgotc;
-       u64 lenerrs;
-       u64 scvpc;
-       u64 hrmpc;
-       u64 doosync;
+       uint64_t crcerrs;
+       uint64_t algnerrc;
+       uint64_t symerrs;
+       uint64_t rxerrc;
+       uint64_t mpc;
+       uint64_t scc;
+       uint64_t ecol;
+       uint64_t mcc;
+       uint64_t latecol;
+       uint64_t colc;
+       uint64_t dc;
+       uint64_t tncrs;
+       uint64_t sec;
+       uint64_t cexterr;
+       uint64_t rlec;
+       uint64_t xonrxc;
+       uint64_t xontxc;
+       uint64_t xoffrxc;
+       uint64_t xofftxc;
+       uint64_t fcruc;
+       uint64_t prc64;
+       uint64_t prc127;
+       uint64_t prc255;
+       uint64_t prc511;
+       uint64_t prc1023;
+       uint64_t prc1522;
+       uint64_t gprc;
+       uint64_t bprc;
+       uint64_t mprc;
+       uint64_t gptc;
+       uint64_t gorc;
+       uint64_t gotc;
+       uint64_t rnbc;
+       uint64_t ruc;
+       uint64_t rfc;
+       uint64_t roc;
+       uint64_t rjc;
+       uint64_t mgprc;
+       uint64_t mgpdc;
+       uint64_t mgptc;
+       uint64_t tor;
+       uint64_t tot;
+       uint64_t tpr;
+       uint64_t tpt;
+       uint64_t ptc64;
+       uint64_t ptc127;
+       uint64_t ptc255;
+       uint64_t ptc511;
+       uint64_t ptc1023;
+       uint64_t ptc1522;
+       uint64_t mptc;
+       uint64_t bptc;
+       uint64_t tsctc;
+       uint64_t tsctfc;
+       uint64_t iac;
+       uint64_t icrxptc;
+       uint64_t icrxatc;
+       uint64_t ictxptc;
+       uint64_t ictxatc;
+       uint64_t ictxqec;
+       uint64_t ictxqmtc;
+       uint64_t icrxdmtc;
+       uint64_t icrxoc;
+       uint64_t cbtmpc;
+       uint64_t htdpmc;
+       uint64_t cbrdpc;
+       uint64_t cbrmpc;
+       uint64_t rpthc;
+       uint64_t hgptc;
+       uint64_t htcbdpc;
+       uint64_t hgorc;
+       uint64_t hgotc;
+       uint64_t lenerrs;
+       uint64_t scvpc;
+       uint64_t hrmpc;
+       uint64_t doosync;
 };
 
 
 struct e1000_phy_stats {
-       u32 idle_errors;
-       u32 receive_errors;
+       uint32_t idle_errors;
+       uint32_t receive_errors;
 };
 
 struct e1000_host_mng_dhcp_cookie {
-       u32 signature;
-       u8  status;
-       u8  reserved0;
-       u16 vlan_id;
-       u32 reserved1;
-       u16 reserved2;
-       u8  reserved3;
-       u8  checksum;
+       uint32_t signature;
+       uint8_t  status;
+       uint8_t  reserved0;
+       uint16_t vlan_id;
+       uint32_t reserved1;
+       uint16_t reserved2;
+       uint8_t  reserved3;
+       uint8_t  checksum;
 };
 
 /* Host Interface "Rev 1" */
 struct e1000_host_command_header {
-       u8 command_id;
-       u8 command_length;
-       u8 command_options;
-       u8 checksum;
+       uint8_t command_id;
+       uint8_t command_length;
+       uint8_t command_options;
+       uint8_t checksum;
 };
 
 #define E1000_HI_MAX_DATA_LENGTH     252
 struct e1000_host_command_info {
        struct e1000_host_command_header command_header;
-       u8 command_data[E1000_HI_MAX_DATA_LENGTH];
+       uint8_t command_data[E1000_HI_MAX_DATA_LENGTH];
 };
 
 /* Host Interface "Rev 2" */
 struct e1000_host_mng_command_header {
-       u8  command_id;
-       u8  checksum;
-       u16 reserved1;
-       u16 reserved2;
-       u16 command_length;
+       uint8_t  command_id;
+       uint8_t  checksum;
+       uint16_t reserved1;
+       uint16_t reserved2;
+       uint16_t command_length;
 };
 
 #define E1000_HI_MAX_MNG_DATA_LENGTH 0x6F8
 struct e1000_host_mng_command_info {
        struct e1000_host_mng_command_header command_header;
-       u8 command_data[E1000_HI_MAX_MNG_DATA_LENGTH];
-};
-
-#include "e1000_mac.h"
-#include "e1000_phy.h"
-#include "e1000_nvm.h"
-#include "e1000_manage.h"
+       uint8_t command_data[E1000_HI_MAX_MNG_DATA_LENGTH];
+};
+
+#include <vfs.h>
+#include <kfs.h>
+#include <slab.h>
+#include <kmalloc.h>
+#include <kref.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <error.h>
+#include <cpio.h>
+#include <pmap.h>
+#include <smp.h>
+#include <ip.h>
 
 struct e1000_mac_operations {
        /* Function pointers for the MAC. */
-       s32  (*init_params)(struct e1000_hw *);
-       s32  (*id_led_init)(struct e1000_hw *);
-       s32  (*blink_led)(struct e1000_hw *);
-       s32  (*check_for_link)(struct e1000_hw *);
+       int32_t  (*init_params)(struct e1000_hw *);
+       int32_t  (*id_led_init)(struct e1000_hw *);
+       int32_t  (*blink_led)(struct e1000_hw *);
+       int32_t  (*check_for_link)(struct e1000_hw *);
        bool (*check_mng_mode)(struct e1000_hw *hw);
-       s32  (*cleanup_led)(struct e1000_hw *);
+       int32_t  (*cleanup_led)(struct e1000_hw *);
        void (*clear_hw_cntrs)(struct e1000_hw *);
        void (*clear_vfta)(struct e1000_hw *);
-       s32  (*get_bus_info)(struct e1000_hw *);
+       int32_t  (*get_bus_info)(struct e1000_hw *);
        void (*set_lan_id)(struct e1000_hw *);
-       s32  (*get_link_up_info)(struct e1000_hw *, u16 *, u16 *);
-       s32  (*led_on)(struct e1000_hw *);
-       s32  (*led_off)(struct e1000_hw *);
-       void (*update_mc_addr_list)(struct e1000_hw *, u8 *, u32);
-       s32  (*reset_hw)(struct e1000_hw *);
-       s32  (*init_hw)(struct e1000_hw *);
-       s32  (*setup_link)(struct e1000_hw *);
-       s32  (*setup_physical_interface)(struct e1000_hw *);
-       s32  (*setup_led)(struct e1000_hw *);
-       void (*write_vfta)(struct e1000_hw *, u32, u32);
-       void (*mta_set)(struct e1000_hw *, u32);
+       int32_t  (*get_link_up_info)(struct e1000_hw *, uint16_t *, uint16_t *);
+       int32_t  (*led_on)(struct e1000_hw *);
+       int32_t  (*led_off)(struct e1000_hw *);
+       void (*update_mc_addr_list)(struct e1000_hw *, uint8_t *, uint32_t);
+       int32_t  (*reset_hw)(struct e1000_hw *);
+       int32_t  (*init_hw)(struct e1000_hw *);
+       int32_t  (*setup_link)(struct e1000_hw *);
+       int32_t  (*setup_physical_interface)(struct e1000_hw *);
+       int32_t  (*setup_led)(struct e1000_hw *);
+       void (*write_vfta)(struct e1000_hw *, uint32_t, uint32_t);
+       void (*mta_set)(struct e1000_hw *, uint32_t);
        void (*config_collision_dist)(struct e1000_hw *);
-       void (*rar_set)(struct e1000_hw *, u8*, u32);
-       s32  (*read_mac_addr)(struct e1000_hw *);
-       s32  (*validate_mdi_setting)(struct e1000_hw *);
-       s32  (*mng_host_if_write)(struct e1000_hw *, u8*, u16, u16, u8*);
-       s32  (*mng_write_cmd_header)(struct e1000_hw *hw,
+       void (*rar_set)(struct e1000_hw *, uint8_t*, uint32_t);
+       int32_t  (*read_mac_addr)(struct e1000_hw *);
+       int32_t  (*validate_mdi_setting)(struct e1000_hw *);
+       int32_t  (*mng_host_if_write)(struct e1000_hw *, uint8_t*, uint16_t,
+                                 uint16_t,
+                                 uint8_t*);
+       int32_t  (*mng_write_cmd_header)(struct e1000_hw *hw,
                       struct e1000_host_mng_command_header*);
-       s32  (*mng_enable_host_if)(struct e1000_hw *);
-       s32  (*wait_autoneg)(struct e1000_hw *);
+       int32_t  (*mng_enable_host_if)(struct e1000_hw *);
+       int32_t  (*wait_autoneg)(struct e1000_hw *);
 };
 
 struct e1000_phy_operations {
-       s32  (*init_params)(struct e1000_hw *);
-       s32  (*acquire)(struct e1000_hw *);
-       s32  (*check_polarity)(struct e1000_hw *);
-       s32  (*check_reset_block)(struct e1000_hw *);
-       s32  (*commit)(struct e1000_hw *);
+       int32_t  (*init_params)(struct e1000_hw *);
+       int32_t  (*acquire)(struct e1000_hw *);
+       int32_t  (*check_polarity)(struct e1000_hw *);
+       int32_t  (*check_reset_block)(struct e1000_hw *);
+       int32_t  (*commit)(struct e1000_hw *);
 #if 0
        s32  (*force_speed_duplex)(struct e1000_hw *);
 #endif
-       s32  (*get_cfg_done)(struct e1000_hw *hw);
+       int32_t  (*get_cfg_done)(struct e1000_hw *hw);
 #if 0
        s32  (*get_cable_length)(struct e1000_hw *);
 #endif
-       s32  (*get_info)(struct e1000_hw *);
-       s32  (*read_reg)(struct e1000_hw *, u32, u16 *);
+       int32_t  (*get_info)(struct e1000_hw *);
+       int32_t  (*read_reg)(struct e1000_hw *, uint32_t, uint16_t *);
        void (*release)(struct e1000_hw *);
-       s32  (*reset)(struct e1000_hw *);
-       s32  (*set_d0_lplu_state)(struct e1000_hw *, bool);
-       s32  (*set_d3_lplu_state)(struct e1000_hw *, bool);
-       s32  (*write_reg)(struct e1000_hw *, u32, u16);
+       int32_t  (*reset)(struct e1000_hw *);
+       int32_t  (*set_d0_lplu_state)(struct e1000_hw *, bool);
+       int32_t  (*set_d3_lplu_state)(struct e1000_hw *, bool);
+       int32_t  (*write_reg)(struct e1000_hw *, uint32_t, uint16_t);
        void (*power_up)(struct e1000_hw *);
        void (*power_down)(struct e1000_hw *);
 };
 
 struct e1000_nvm_operations {
-       s32  (*init_params)(struct e1000_hw *);
-       s32  (*acquire)(struct e1000_hw *);
-       s32  (*read)(struct e1000_hw *, u16, u16, u16 *);
+       int32_t  (*init_params)(struct e1000_hw *);
+       int32_t  (*acquire)(struct e1000_hw *);
+       int32_t  (*read)(struct e1000_hw *, uint16_t, uint16_t, uint16_t *);
        void (*release)(struct e1000_hw *);
        void (*reload)(struct e1000_hw *);
-       s32  (*update)(struct e1000_hw *);
-       s32  (*valid_led_default)(struct e1000_hw *, u16 *);
-       s32  (*validate)(struct e1000_hw *);
-       s32  (*write)(struct e1000_hw *, u16, u16, u16 *);
+       int32_t  (*update)(struct e1000_hw *);
+       int32_t  (*valid_led_default)(struct e1000_hw *, uint16_t *);
+       int32_t  (*validate)(struct e1000_hw *);
+       int32_t  (*write)(struct e1000_hw *, uint16_t, uint16_t, uint16_t *);
 };
 
 struct e1000_mac_info {
        struct e1000_mac_operations ops;
-       u8 addr[6];
-       u8 perm_addr[6];
+       uint8_t addr[6];
+       uint8_t perm_addr[6];
 
        enum e1000_mac_type type;
 
-       u32 collision_delta;
-       u32 ledctl_default;
-       u32 ledctl_mode1;
-       u32 ledctl_mode2;
-       u32 mc_filter_type;
-       u32 tx_packet_delta;
-       u32 txcw;
-
-       u16 current_ifs_val;
-       u16 ifs_max_val;
-       u16 ifs_min_val;
-       u16 ifs_ratio;
-       u16 ifs_step_size;
-       u16 mta_reg_count;
+       uint32_t collision_delta;
+       uint32_t ledctl_default;
+       uint32_t ledctl_mode1;
+       uint32_t ledctl_mode2;
+       uint32_t mc_filter_type;
+       uint32_t tx_packet_delta;
+       uint32_t txcw;
+
+       uint16_t current_ifs_val;
+       uint16_t ifs_max_val;
+       uint16_t ifs_min_val;
+       uint16_t ifs_ratio;
+       uint16_t ifs_step_size;
+       uint16_t mta_reg_count;
 
        /* Maximum size of the MTA register table in all supported adapters */
        #define MAX_MTA_REG 128
-       u32 mta_shadow[MAX_MTA_REG];
-       u16 rar_entry_count;
+       uint32_t mta_shadow[MAX_MTA_REG];
+       uint16_t rar_entry_count;
 
-       u8  forced_speed_duplex;
+       uint8_t  forced_speed_duplex;
 
        bool adaptive_ifs;
        bool arc_subsystem_valid;
@@ -613,20 +633,20 @@ struct e1000_phy_info {
        enum e1000_rev_polarity cable_polarity;
        enum e1000_smart_speed smart_speed;
 
-       u32 addr;
-       u32 id;
-       u32 reset_delay_us; /* in usec */
-       u32 revision;
+       uint32_t addr;
+       uint32_t id;
+       uint32_t reset_delay_us; /* in usec */
+       uint32_t revision;
 
        enum e1000_media_type media_type;
 
-       u16 autoneg_advertised;
-       u16 autoneg_mask;
-       u16 cable_length;
-       u16 max_cable_length;
-       u16 min_cable_length;
+       uint16_t autoneg_advertised;
+       uint16_t autoneg_mask;
+       uint16_t cable_length;
+       uint16_t max_cable_length;
+       uint16_t min_cable_length;
 
-       u8 mdix;
+       uint8_t mdix;
 
        bool disable_polarity_correction;
        bool is_mdix;
@@ -641,14 +661,14 @@ struct e1000_nvm_info {
        enum e1000_nvm_type type;
        enum e1000_nvm_override override;
 
-       u32 flash_bank_size;
-       u32 flash_base_addr;
+       uint32_t flash_bank_size;
+       uint32_t flash_base_addr;
 
-       u16 word_size;
-       u16 delay_usec;
-       u16 address_bits;
-       u16 opcode_bits;
-       u16 page_size;
+       uint16_t word_size;
+       uint16_t delay_usec;
+       uint16_t address_bits;
+       uint16_t opcode_bits;
+       uint16_t page_size;
 };
 
 struct e1000_bus_info {
@@ -656,14 +676,14 @@ struct e1000_bus_info {
        enum e1000_bus_speed speed;
        enum e1000_bus_width width;
 
-       u16 func;
-       u16 pci_cmd_word;
+       uint16_t func;
+       uint16_t pci_cmd_word;
 };
 
 struct e1000_fc_info {
-       u32 high_water;          /* Flow control high-water mark */
-       u32 low_water;           /* Flow control low-water mark */
-       u16 pause_time;          /* Flow control pause timer */
+       uint32_t high_water;          /* Flow control high-water mark */
+       uint32_t low_water;           /* Flow control low-water mark */
+       uint16_t pause_time;          /* Flow control pause timer */
        bool send_xon;           /* Flow control send XON */
        bool strict_ieee;        /* Strict IEEE mode */
        enum e1000_fc_mode current_mode; /* FC mode in effect */
@@ -673,7 +693,7 @@ struct e1000_fc_info {
 struct e1000_dev_spec_82541 {
        enum e1000_dsp_config dsp_config;
        enum e1000_ffe_config ffe_config;
-       u16 spd_default;
+       uint16_t spd_default;
        bool phy_init_script;
 };
 
@@ -682,7 +702,7 @@ struct e1000_dev_spec_82542 {
 };
 
 struct e1000_dev_spec_82543 {
-       u32  tbi_compatibility;
+       uint32_t  tbi_compatibility;
        bool dma_fairness;
        bool init_phy_disabled;
 };
@@ -690,8 +710,8 @@ struct e1000_dev_spec_82543 {
 struct e1000_hw {
        void *back;
 
-       u8 __iomem *hw_addr;
-       u8 __iomem *flash_address;
+       uint8_t  *hw_addr;
+       uint8_t  *flash_address;
        unsigned long io_base;
 
        struct e1000_mac_info  mac;
@@ -707,22 +727,34 @@ struct e1000_hw {
                struct e1000_dev_spec_82543     _82543;
        } dev_spec;
 
-       u16 device_id;
-       u16 subsystem_vendor_id;
-       u16 subsystem_device_id;
-       u16 vendor_id;
+       uint16_t device_id;
+       uint16_t subsystem_vendor_id;
+       uint16_t subsystem_device_id;
+       uint16_t vendor_id;
 
-       u8  revision_id;
+       uint8_t  revision_id;
 };
 
-#include "e1000_82541.h"
-#include "e1000_82543.h"
+#include <vfs.h>
+#include <kfs.h>
+#include <slab.h>
+#include <kmalloc.h>
+#include <kref.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <error.h>
+#include <cpio.h>
+#include <pmap.h>
+#include <smp.h>
+#include <ip.h>
 
 /* These functions must be implemented by drivers */
 void e1000_pci_clear_mwi(struct e1000_hw *hw);
 void e1000_pci_set_mwi(struct e1000_hw *hw);
-s32  e1000_read_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value);
-void e1000_read_pci_cfg(struct e1000_hw *hw, u32 reg, u16 *value);
-void e1000_write_pci_cfg(struct e1000_hw *hw, u32 reg, u16 *value);
+int32_t  e1000_read_pcie_cap_reg(struct e1000_hw *hw,
+                            uint32_t reg, uint16_t *value);
+void e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value);
+void e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value);
 
 #endif
index 2351387..6315333 100644 (file)
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
 
+#include <vfs.h>
+#include <kfs.h>
+#include <slab.h>
+#include <kmalloc.h>
+#include <kref.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <error.h>
+#include <cpio.h>
+#include <pmap.h>
+#include <smp.h>
+#include <ip.h>
 #include "e1000_api.h"
+#include "e1000_mac.h"
+#include "e1000_nvm.h"
 
-static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw);
+static int32_t e1000_validate_mdi_setting_generic(struct e1000_hw *hw);
 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
 
 /**
@@ -42,7 +56,7 @@ static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
 void e1000_init_mac_ops_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
-       DEBUGFUNC("e1000_init_mac_ops_generic");
+       printd("e1000_init_mac_ops_generic");
 
        /* General Setup */
        mac->ops.init_params = e1000_null_ops_generic;
@@ -85,9 +99,9 @@ void e1000_init_mac_ops_generic(struct e1000_hw *hw)
  *  e1000_null_ops_generic - No-op function, returns 0
  *  @hw: pointer to the HW structure
  **/
-s32 e1000_null_ops_generic(struct e1000_hw *hw __unused)
+int32_t e1000_null_ops_generic(struct e1000_hw *hw )
 {
-       DEBUGFUNC("e1000_null_ops_generic");
+       printd("e1000_null_ops_generic");
        return E1000_SUCCESS;
 }
 
@@ -95,9 +109,9 @@ s32 e1000_null_ops_generic(struct e1000_hw *hw __unused)
  *  e1000_null_mac_generic - No-op function, return void
  *  @hw: pointer to the HW structure
  **/
-void e1000_null_mac_generic(struct e1000_hw *hw __unused)
+void e1000_null_mac_generic(struct e1000_hw *hw )
 {
-       DEBUGFUNC("e1000_null_mac_generic");
+       printd("e1000_null_mac_generic");
        return;
 }
 
@@ -105,10 +119,10 @@ void e1000_null_mac_generic(struct e1000_hw *hw __unused)
  *  e1000_null_link_info - No-op function, return 0
  *  @hw: pointer to the HW structure
  **/
-s32 e1000_null_link_info(struct e1000_hw *hw __unused,
-                         u16 *s __unused, u16 *d __unused)
+int32_t e1000_null_link_info(struct e1000_hw *hw ,
+                         uint16_t *s , uint16_t *d )
 {
-       DEBUGFUNC("e1000_null_link_info");
+       printd("e1000_null_link_info");
        return E1000_SUCCESS;
 }
 
@@ -116,9 +130,9 @@ s32 e1000_null_link_info(struct e1000_hw *hw __unused,
  *  e1000_null_mng_mode - No-op function, return false
  *  @hw: pointer to the HW structure
  **/
-bool e1000_null_mng_mode(struct e1000_hw *hw __unused)
+bool e1000_null_mng_mode(struct e1000_hw *hw )
 {
-       DEBUGFUNC("e1000_null_mng_mode");
+       printd("e1000_null_mng_mode");
        return false;
 }
 
@@ -126,10 +140,10 @@ bool e1000_null_mng_mode(struct e1000_hw *hw __unused)
  *  e1000_null_update_mc - No-op function, return void
  *  @hw: pointer to the HW structure
  **/
-void e1000_null_update_mc(struct e1000_hw *hw __unused,
-                          u8 *h __unused, u32 a __unused)
+void e1000_null_update_mc(struct e1000_hw *hw ,
+                          uint8_t *h , uint32_t a )
 {
-       DEBUGFUNC("e1000_null_update_mc");
+       printd("e1000_null_update_mc");
        return;
 }
 
@@ -137,10 +151,10 @@ void e1000_null_update_mc(struct e1000_hw *hw __unused,
  *  e1000_null_write_vfta - No-op function, return void
  *  @hw: pointer to the HW structure
  **/
-void e1000_null_write_vfta(struct e1000_hw *hw __unused,
-                           u32 a __unused, u32 b __unused)
+void e1000_null_write_vfta(struct e1000_hw *hw ,
+                           uint32_t a , uint32_t b )
 {
-       DEBUGFUNC("e1000_null_write_vfta");
+       printd("e1000_null_write_vfta");
        return;
 }
 
@@ -148,9 +162,9 @@ void e1000_null_write_vfta(struct e1000_hw *hw __unused,
  *  e1000_null_set_mta - No-op function, return void
  *  @hw: pointer to the HW structure
  **/
-void e1000_null_mta_set(struct e1000_hw *hw __unused, u32 a __unused)
+void e1000_null_mta_set(struct e1000_hw *hw , uint32_t a )
 {
-       DEBUGFUNC("e1000_null_mta_set");
+       printd("e1000_null_mta_set");
        return;
 }
 
@@ -158,10 +172,10 @@ void e1000_null_mta_set(struct e1000_hw *hw __unused, u32 a __unused)
  *  e1000_null_rar_set - No-op function, return void
  *  @hw: pointer to the HW structure
  **/
-void e1000_null_rar_set(struct e1000_hw *hw __unused, u8 *h __unused,
-                        u32 a __unused)
+void e1000_null_rar_set(struct e1000_hw *hw , uint8_t *h ,
+                        uint32_t a )
 {
-       DEBUGFUNC("e1000_null_rar_set");
+       printd("e1000_null_rar_set");
        return;
 }
 
@@ -173,7 +187,7 @@ void e1000_null_rar_set(struct e1000_hw *hw __unused, u8 *h __unused,
  *  network interface.  The following bus information is determined and stored:
  *  bus speed, bus width, type (PCI/PCIx), and PCI(-x) function.
  **/
-s32 e1000_get_bus_info_pci_generic(struct e1000_hw *hw __unused)
+int32_t e1000_get_bus_info_pci_generic(struct e1000_hw *hw )
 {
 #if 0
        struct e1000_mac_info *mac = &hw->mac;
@@ -231,7 +245,7 @@ s32 e1000_get_bus_info_pci_generic(struct e1000_hw *hw __unused)
  *  network interface.  The following bus information is determined and stored:
  *  bus speed, bus width, type (PCIe), and PCIe function.
  **/
-s32 e1000_get_bus_info_pcie_generic(struct e1000_hw *hw __unused)
+int32_t e1000_get_bus_info_pcie_generic(struct e1000_hw *hw )
 {
 #if 0
        struct e1000_mac_info *mac = &hw->mac;
@@ -273,7 +287,7 @@ s32 e1000_get_bus_info_pcie_generic(struct e1000_hw *hw __unused)
 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw)
 {
        struct e1000_bus_info *bus = &hw->bus;
-       u32 reg;
+       uint32_t reg;
 
        /*
         * The status register reports the correct function number
@@ -292,8 +306,8 @@ static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw)
 void e1000_set_lan_id_multi_port_pci(struct e1000_hw *hw)
 {
        struct e1000_bus_info *bus = &hw->bus;
-       u16 pci_header_type;
-       u32 status;
+       uint16_t pci_header_type;
+       uint32_t status;
 
        e1000_read_pci_cfg(hw, PCI_HEADER_TYPE_REGISTER, &pci_header_type);
        if (pci_header_type & PCI_HEADER_TYPE_MULTIFUNC) {
@@ -327,9 +341,9 @@ void e1000_set_lan_id_single_port(struct e1000_hw *hw)
  **/
 void e1000_clear_vfta_generic(struct e1000_hw *hw)
 {
-       u32 offset;
+       uint32_t offset;
 
-       DEBUGFUNC("e1000_clear_vfta_generic");
+       printd("e1000_clear_vfta_generic");
 
        for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
                E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0);
@@ -346,9 +360,10 @@ void e1000_clear_vfta_generic(struct e1000_hw *hw)
  *  Writes value at the given offset in the register array which stores
  *  the VLAN filter table.
  **/
-void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value)
+void e1000_write_vfta_generic(struct e1000_hw *hw, uint32_t offset,
+                             uint32_t value)
 {
-       DEBUGFUNC("e1000_write_vfta_generic");
+       printd("e1000_write_vfta_generic");
 
        E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
        E1000_WRITE_FLUSH(hw);
@@ -363,12 +378,12 @@ void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value)
  *  register to the devices MAC address and clearing all the other receive
  *  address registers to 0.
  **/
-void e1000_init_rx_addrs_generic(struct e1000_hw *hw, u16 rar_count)
+void e1000_init_rx_addrs_generic(struct e1000_hw *hw, uint16_t rar_count)
 {
-       u32 i;
-       u8 mac_addr[ETH_ADDR_LEN] = {0};
+       uint32_t i;
+       uint8_t mac_addr[ETH_ADDR_LEN] = {0};
 
-       DEBUGFUNC("e1000_init_rx_addrs_generic");
+       printd("e1000_init_rx_addrs_generic");
 
        /* Setup the receive address */
        DEBUGOUT("Programming MAC Address into RAR[0]\n");
@@ -393,14 +408,14 @@ void e1000_init_rx_addrs_generic(struct e1000_hw *hw, u16 rar_count)
  *  This function will return SUCCESS unless it encounters an error while
  *  reading the EEPROM.
  **/
-s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
+int32_t e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
 {
-       u32 i;
-       s32 ret_val = E1000_SUCCESS;
-       u16 offset, nvm_alt_mac_addr_offset, nvm_data;
-       u8 alt_mac_addr[ETH_ADDR_LEN];
+       uint32_t i;
+       int32_t ret_val = E1000_SUCCESS;
+       uint16_t offset, nvm_alt_mac_addr_offset, nvm_data;
+       uint8_t alt_mac_addr[ETH_ADDR_LEN];
 
-       DEBUGFUNC("e1000_check_alt_mac_addr_generic");
+       printd("e1000_check_alt_mac_addr_generic");
 
        ret_val = hw->nvm.ops.read(hw, NVM_ALT_MAC_ADDR_PTR, 1,
                                 &nvm_alt_mac_addr_offset);
@@ -424,8 +439,8 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
                        goto out;
                }
 
-               alt_mac_addr[i] = (u8)(nvm_data & 0xFF);
-               alt_mac_addr[i + 1] = (u8)(nvm_data >> 8);
+               alt_mac_addr[i] = (uint8_t)(nvm_data & 0xFF);
+               alt_mac_addr[i + 1] = (uint8_t)(nvm_data >> 8);
        }
 
        /* if multicast bit is set, the alternate address will not be used */
@@ -454,21 +469,21 @@ out:
  *  Sets the receive address array register at index to the address passed
  *  in by addr.
  **/
-void e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
+void e1000_rar_set_generic(struct e1000_hw *hw, uint8_t *addr, uint32_t index)
 {
-       u32 rar_low, rar_high;
+       uint32_t rar_low, rar_high;
 
-       DEBUGFUNC("e1000_rar_set_generic");
+       printd("e1000_rar_set_generic");
 
        /*
         * HW expects these in little endian so we reverse the byte order
         * from network order (big endian) to little endian
         */
-       rar_low = ((u32) addr[0] |
-                  ((u32) addr[1] << 8) |
-                  ((u32) addr[2] << 16) | ((u32) addr[3] << 24));
+       rar_low = ((uint32_t) addr[0] |
+                  ((uint32_t) addr[1] << 8) |
+                  ((uint32_t) addr[2] << 16) | ((uint32_t) addr[3] << 24));
 
-       rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
+       rar_high = ((uint32_t) addr[4] | ((uint32_t) addr[5] << 8));
 
        /* If MAC address zero, no need to set the AV bit */
        if (rar_low || rar_high)
@@ -495,11 +510,11 @@ void e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
  *  current value is read, the new bit is OR'd in and the new value is
  *  written back into the register.
  **/
-void e1000_mta_set_generic(struct e1000_hw *hw, u32 hash_value)
+void e1000_mta_set_generic(struct e1000_hw *hw, uint32_t hash_value)
 {
-       u32 hash_bit, hash_reg, mta;
+       uint32_t hash_bit, hash_reg, mta;
 
-       DEBUGFUNC("e1000_mta_set_generic");
+       printd("e1000_mta_set_generic");
        /*
         * The MTA is a register array of 32-bit registers. It is
         * treated like an array of (32*mta_reg_count) bits.  We want to
@@ -531,18 +546,19 @@ void e1000_mta_set_generic(struct e1000_hw *hw, u32 hash_value)
  *  The caller must have a packed mc_addr_list of multicast addresses.
  **/
 void e1000_update_mc_addr_list_generic(struct e1000_hw *hw,
-                                       u8 *mc_addr_list, u32 mc_addr_count)
+                                       uint8_t *mc_addr_list,
+                                      uint32_t mc_addr_count)
 {
-       u32 hash_value, hash_bit, hash_reg;
+       uint32_t hash_value, hash_bit, hash_reg;
        int i;
 
-       DEBUGFUNC("e1000_update_mc_addr_list_generic");
+       printd("e1000_update_mc_addr_list_generic");
 
        /* clear mta_shadow */
        memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
 
        /* update mta_shadow from mc_addr_list */
-       for (i = 0; (u32) i < mc_addr_count; i++) {
+       for (i = 0; (uint32_t) i < mc_addr_count; i++) {
                hash_value = e1000_hash_mc_addr_generic(hw, mc_addr_list);
 
                hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
@@ -567,12 +583,12 @@ void e1000_update_mc_addr_list_generic(struct e1000_hw *hw,
  *  the multicast filter table array address and new table value.  See
  *  e1000_mta_set_generic()
  **/
-u32 e1000_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr)
+uint32_t e1000_hash_mc_addr_generic(struct e1000_hw *hw, uint8_t *mc_addr)
 {
-       u32 hash_value, hash_mask;
-       u8 bit_shift = 0;
+       uint32_t hash_value, hash_mask;
+       uint8_t bit_shift = 0;
 
-       DEBUGFUNC("e1000_hash_mc_addr_generic");
+       printd("e1000_hash_mc_addr_generic");
 
        /* Register count multiplied by bits per register */
        hash_mask = (hw->mac.mta_reg_count * 32) - 1;
@@ -626,7 +642,7 @@ u32 e1000_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr)
        }
 
        hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
-                                 (((u16) mc_addr[5]) << bit_shift)));
+                                 (((uint16_t) mc_addr[5]) << bit_shift)));
 
        return hash_value;
 }
@@ -642,12 +658,12 @@ u32 e1000_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr)
  **/
 void e1000_pcix_mmrbc_workaround_generic(struct e1000_hw *hw)
 {
-       u16 cmd_mmrbc;
-       u16 pcix_cmd;
-       u16 pcix_stat_hi_word;
-       u16 stat_mmrbc;
+       uint16_t cmd_mmrbc;
+       uint16_t pcix_cmd;
+       uint16_t pcix_stat_hi_word;
+       uint16_t stat_mmrbc;
 
-       DEBUGFUNC("e1000_pcix_mmrbc_workaround_generic");
+       printd("e1000_pcix_mmrbc_workaround_generic");
 
        /* Workaround for PCI-X issue when BIOS sets MMRBC incorrectly */
        if (hw->bus.type != e1000_bus_type_pcix)
@@ -674,9 +690,9 @@ void e1000_pcix_mmrbc_workaround_generic(struct e1000_hw *hw)
  *
  *  Clears the base hardware counters by reading the counter registers.
  **/
-void e1000_clear_hw_cntrs_base_generic(struct e1000_hw *hw __unused)
+void e1000_clear_hw_cntrs_base_generic(struct e1000_hw *hw )
 {
-       DEBUGFUNC("e1000_clear_hw_cntrs_base_generic");
+       printd("e1000_clear_hw_cntrs_base_generic");
 
 #if 0
        E1000_READ_REG(hw, E1000_CRCERRS);
@@ -727,13 +743,13 @@ void e1000_clear_hw_cntrs_base_generic(struct e1000_hw *hw __unused)
  *  change in link status has been detected, then we read the PHY registers
  *  to get the current speed/duplex if link exists.
  **/
-s32 e1000_check_for_copper_link_generic(struct e1000_hw *hw)
+int32_t e1000_check_for_copper_link_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
-       s32 ret_val;
+       int32_t ret_val;
        bool link;
 
-       DEBUGFUNC("e1000_check_for_copper_link");
+       printd("e1000_check_for_copper_link");
 
        /*
         * We only want to go out to the PHY registers to see if Auto-Neg
@@ -803,15 +819,15 @@ out:
  *  Checks for link up on the hardware.  If link is not up and we have
  *  a signal, then we need to force link up.
  **/
-s32 e1000_check_for_fiber_link_generic(struct e1000_hw *hw)
+int32_t e1000_check_for_fiber_link_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
-       u32 rxcw;
-       u32 ctrl;
-       u32 status;
-       s32 ret_val = E1000_SUCCESS;
+       uint32_t rxcw;
+       uint32_t ctrl;
+       uint32_t status;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_check_for_fiber_link_generic");
+       printd("e1000_check_for_fiber_link_generic");
 
        ctrl = E1000_READ_REG(hw, E1000_CTRL);
        status = E1000_READ_REG(hw, E1000_STATUS);
@@ -873,15 +889,15 @@ out:
  *  Checks for link up on the hardware.  If link is not up and we have
  *  a signal, then we need to force link up.
  **/
-s32 e1000_check_for_serdes_link_generic(struct e1000_hw *hw)
+int32_t e1000_check_for_serdes_link_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
-       u32 rxcw;
-       u32 ctrl;
-       u32 status;
-       s32 ret_val = E1000_SUCCESS;
+       uint32_t rxcw;
+       uint32_t ctrl;
+       uint32_t status;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_check_for_serdes_link_generic");
+       printd("e1000_check_for_serdes_link_generic");
 
        ctrl = E1000_READ_REG(hw, E1000_CTRL);
        status = E1000_READ_REG(hw, E1000_STATUS);
@@ -988,11 +1004,11 @@ out:
  *  should be established.  Assumes the hardware has previously been reset
  *  and the transmitter and receiver are not enabled.
  **/
-s32 e1000_setup_link_generic(struct e1000_hw *hw)
+int32_t e1000_setup_link_generic(struct e1000_hw *hw)
 {
-       s32 ret_val = E1000_SUCCESS;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_setup_link_generic");
+       printd("e1000_setup_link_generic");
 
        /*
         * In the case of the phy reset being blocked, we already have a link.
@@ -1052,12 +1068,12 @@ out:
  *  Configures collision distance and flow control for fiber and serdes
  *  links.  Upon successful setup, poll for link.
  **/
-s32 e1000_setup_fiber_serdes_link_generic(struct e1000_hw *hw)
+int32_t e1000_setup_fiber_serdes_link_generic(struct e1000_hw *hw)
 {
-       u32 ctrl;
-       s32 ret_val = E1000_SUCCESS;
+       uint32_t ctrl;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_setup_fiber_serdes_link_generic");
+       printd("e1000_setup_fiber_serdes_link_generic");
 
        ctrl = E1000_READ_REG(hw, E1000_CTRL);
 
@@ -1109,9 +1125,9 @@ out:
  **/
 void e1000_config_collision_dist_generic(struct e1000_hw *hw)
 {
-       u32 tctl;
+       uint32_t tctl;
 
-       DEBUGFUNC("e1000_config_collision_dist_generic");
+       printd("e1000_config_collision_dist_generic");
 
        tctl = E1000_READ_REG(hw, E1000_TCTL);
 
@@ -1129,13 +1145,13 @@ void e1000_config_collision_dist_generic(struct e1000_hw *hw)
  *  Polls for link up by reading the status register, if link fails to come
  *  up with auto-negotiation, then the link is forced if a signal is detected.
  **/
-s32 e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw)
+int32_t e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
-       u32 i, status;
-       s32 ret_val = E1000_SUCCESS;
+       uint32_t i, status;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_poll_fiber_serdes_link_generic");
+       printd("e1000_poll_fiber_serdes_link_generic");
 
        /*
         * If we have a signal (the cable is plugged in, or assumed true for
@@ -1181,13 +1197,13 @@ out:
  *  Write the flow control settings to the Transmit Config Word Register (TXCW)
  *  base on the flow control settings in e1000_mac_info.
  **/
-s32 e1000_commit_fc_settings_generic(struct e1000_hw *hw)
+int32_t e1000_commit_fc_settings_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
-       u32 txcw;
-       s32 ret_val = E1000_SUCCESS;
+       uint32_t txcw;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_commit_fc_settings_generic");
+       printd("e1000_commit_fc_settings_generic");
 
        /*
         * Check for a software override of the flow control settings, and
@@ -1258,12 +1274,12 @@ out:
  *  flow control XON frame transmission is enabled, then set XON frame
  *  transmission as well.
  **/
-s32 e1000_set_fc_watermarks_generic(struct e1000_hw *hw)
+int32_t e1000_set_fc_watermarks_generic(struct e1000_hw *hw)
 {
-       s32 ret_val = E1000_SUCCESS;
-       u32 fcrtl = 0, fcrth = 0;
+       int32_t ret_val = E1000_SUCCESS;
+       uint32_t fcrtl = 0, fcrth = 0;
 
-       DEBUGFUNC("e1000_set_fc_watermarks_generic");
+       printd("e1000_set_fc_watermarks_generic");
 
        /*
         * Set the flow control receive threshold registers.  Normally,
@@ -1297,12 +1313,12 @@ s32 e1000_set_fc_watermarks_generic(struct e1000_hw *hw)
  *  Read the EEPROM for the default values for flow control and store the
  *  values.
  **/
-s32 e1000_set_default_fc_generic(struct e1000_hw *hw)
+int32_t e1000_set_default_fc_generic(struct e1000_hw *hw)
 {
-       s32 ret_val = E1000_SUCCESS;
-       u16 nvm_data;
+       int32_t ret_val = E1000_SUCCESS;
+       uint16_t nvm_data;
 
-       DEBUGFUNC("e1000_set_default_fc_generic");
+       printd("e1000_set_default_fc_generic");
 
        /*
         * Read and store word 0x0F of the EEPROM. This word contains bits
@@ -1342,12 +1358,12 @@ out:
  *  autonegotiation is managed by the PHY rather than the MAC.  Software must
  *  also configure these bits when link is forced on a fiber connection.
  **/
-s32 e1000_force_mac_fc_generic(struct e1000_hw *hw)
+int32_t e1000_force_mac_fc_generic(struct e1000_hw *hw)
 {
-       u32 ctrl;
-       s32 ret_val = E1000_SUCCESS;
+       uint32_t ctrl;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_force_mac_fc_generic");
+       printd("e1000_force_mac_fc_generic");
 
        ctrl = E1000_READ_REG(hw, E1000_CTRL);
 
@@ -1408,14 +1424,14 @@ out:
  *  and did not fail, then we configure flow control based on our link
  *  partner.
  **/
-s32 e1000_config_fc_after_link_up_generic(struct e1000_hw *hw)
+int32_t e1000_config_fc_after_link_up_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
-       s32 ret_val = E1000_SUCCESS;
-       u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg;
-       u16 speed, duplex;
+       int32_t ret_val = E1000_SUCCESS;
+       uint16_t mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg;
+       uint16_t speed, duplex;
 
-       DEBUGFUNC("e1000_config_fc_after_link_up_generic");
+       printd("e1000_config_fc_after_link_up_generic");
 
        /*
         * Check for the case where we have fiber media and auto-neg failed
@@ -1605,12 +1621,12 @@ out:
  *  Read the status register for the current speed/duplex and store the current
  *  speed and duplex for copper connections.
  **/
-s32 e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, u16 *speed,
-                                              u16 *duplex)
+int32_t e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, uint16_t *speed,
+                                              uint16_t *duplex)
 {
-       u32 status;
+       uint32_t status;
 
-       DEBUGFUNC("e1000_get_speed_and_duplex_copper_generic");
+       printd("e1000_get_speed_and_duplex_copper_generic");
 
        status = E1000_READ_REG(hw, E1000_STATUS);
        if (status & E1000_STATUS_SPEED_1000) {
@@ -1644,10 +1660,11 @@ s32 e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, u16 *speed,
  *  Sets the speed and duplex to gigabit full duplex (the only possible option)
  *  for fiber/serdes links.
  **/
-s32 e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw *hw __unused,
-                                                    u16 *speed, u16 *duplex)
+int32_t e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw *hw ,
+                                                    uint16_t *speed,
+                                                   uint16_t *duplex)
 {
-       DEBUGFUNC("e1000_get_speed_and_duplex_fiber_serdes_generic");
+       printd("e1000_get_speed_and_duplex_fiber_serdes_generic");
 
        *speed = SPEED_1000;
        *duplex = FULL_DUPLEX;
@@ -1661,7 +1678,7 @@ s32 e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw *hw __unused
  *
  *  Acquire the HW semaphore to access the PHY or NVM
  **/
-s32 e1000_get_hw_semaphore_generic(struct e1000_hw *hw __unused)
+int32_t e1000_get_hw_semaphore_generic(struct e1000_hw *hw )
 {
 #if 0
        u32 swsm;
@@ -1719,7 +1736,7 @@ out:
  *
  *  Release hardware semaphore used to access the PHY or NVM
  **/
-void e1000_put_hw_semaphore_generic(struct e1000_hw *hw __unused)
+void e1000_put_hw_semaphore_generic(struct e1000_hw *hw )
 {
 #if 0
        u32 swsm;
@@ -1740,12 +1757,12 @@ void e1000_put_hw_semaphore_generic(struct e1000_hw *hw __unused)
  *
  *  Check EEPROM for Auto Read done bit.
  **/
-s32 e1000_get_auto_rd_done_generic(struct e1000_hw *hw)
+int32_t e1000_get_auto_rd_done_generic(struct e1000_hw *hw)
 {
-       s32 i = 0;
-       s32 ret_val = E1000_SUCCESS;
+       int32_t i = 0;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_get_auto_rd_done_generic");
+       printd("e1000_get_auto_rd_done_generic");
 
        while (i < AUTO_READ_DONE_TIMEOUT) {
                if (E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_AUTO_RD)
@@ -1772,11 +1789,11 @@ out:
  *  Read the EEPROM for the current default LED configuration.  If the
  *  LED configuration is not valid, set to a valid LED configuration.
  **/
-s32 e1000_valid_led_default_generic(struct e1000_hw *hw, u16 *data)
+int32_t e1000_valid_led_default_generic(struct e1000_hw *hw, uint16_t *data)
 {
-       s32 ret_val;
+       int32_t ret_val;
 
-       DEBUGFUNC("e1000_valid_led_default_generic");
+       printd("e1000_valid_led_default_generic");
 
        ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
        if (ret_val) {
@@ -1796,7 +1813,7 @@ out:
  *  @hw: pointer to the HW structure
  *
  **/
-s32 e1000_id_led_init_generic(struct e1000_hw *hw __unused)
+int32_t e1000_id_led_init_generic(struct e1000_hw *hw )
 {
 #if 0
        struct e1000_mac_info *mac = &hw->mac;
@@ -1868,7 +1885,7 @@ out:
  *  This prepares the SW controllable LED for use and saves the current state
  *  of the LED so it can be later restored.
  **/
-s32 e1000_setup_led_generic(struct e1000_hw *hw __unused)
+int32_t e1000_setup_led_generic(struct e1000_hw *hw )
 {
 #if 0
        u32 ledctl;
@@ -1908,7 +1925,7 @@ out:
  *  Remove the current LED configuration and set the LED configuration
  *  to the default value, saved from the EEPROM.
  **/
-s32 e1000_cleanup_led_generic(struct e1000_hw *hw __unused)
+int32_t e1000_cleanup_led_generic(struct e1000_hw *hw )
 {
 #if 0
        s32 ret_val = E1000_SUCCESS;
@@ -1934,7 +1951,7 @@ out:
  *
  *  Blink the LEDs which are set to be on.
  **/
-s32 e1000_blink_led_generic(struct e1000_hw *hw __unused)
+int32_t e1000_blink_led_generic(struct e1000_hw *hw )
 {
 #if 0
        u32 ledctl_blink = 0;
@@ -1972,7 +1989,7 @@ s32 e1000_blink_led_generic(struct e1000_hw *hw __unused)
  *
  *  Turn LED on.
  **/
-s32 e1000_led_on_generic(struct e1000_hw *hw __unused)
+int32_t e1000_led_on_generic(struct e1000_hw *hw )
 {
 #if 0
        u32 ctrl;
@@ -2004,7 +2021,7 @@ s32 e1000_led_on_generic(struct e1000_hw *hw __unused)
  *
  *  Turn LED off.
  **/
-s32 e1000_led_off_generic(struct e1000_hw *hw __unused)
+int32_t e1000_led_off_generic(struct e1000_hw *hw )
 {
 #if 0
        u32 ctrl;
@@ -2037,11 +2054,11 @@ s32 e1000_led_off_generic(struct e1000_hw *hw __unused)
  *
  *  Set the PCI-express register to snoop for events enabled in 'no_snoop'.
  **/
-void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, u32 no_snoop)
+void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, uint32_t no_snoop)
 {
-       u32 gcr;
+       uint32_t gcr;
 
-       DEBUGFUNC("e1000_set_pcie_no_snoop_generic");
+       printd("e1000_set_pcie_no_snoop_generic");
 
        if (hw->bus.type != e1000_bus_type_pci_express)
                goto out;
@@ -2067,13 +2084,13 @@ out:
  *  Disables PCI-Express master access and verifies there are no pending
  *  requests.
  **/
-s32 e1000_disable_pcie_master_generic(struct e1000_hw *hw)
+int32_t e1000_disable_pcie_master_generic(struct e1000_hw *hw)
 {
-       u32 ctrl;
-       s32 timeout = MASTER_DISABLE_TIMEOUT;
-       s32 ret_val = E1000_SUCCESS;
+       uint32_t ctrl;
+       int32_t timeout = MASTER_DISABLE_TIMEOUT;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_disable_pcie_master_generic");
+       printd("e1000_disable_pcie_master_generic");
 
        if (hw->bus.type != e1000_bus_type_pci_express)
                goto out;
@@ -2110,7 +2127,7 @@ void e1000_reset_adaptive_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
 
-       DEBUGFUNC("e1000_reset_adaptive_generic");
+       printd("e1000_reset_adaptive_generic");
 
        if (!mac->adaptive_ifs) {
                DEBUGOUT("Not in Adaptive IFS mode!\n");
@@ -2140,7 +2157,7 @@ void e1000_update_adaptive_generic(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
 
-       DEBUGFUNC("e1000_update_adaptive_generic");
+       printd("e1000_update_adaptive_generic");
 
        if (!mac->adaptive_ifs) {
                DEBUGOUT("Not in Adaptive IFS mode!\n");
@@ -2178,11 +2195,11 @@ out:
  *  Verify that when not using auto-negotiation that MDI/MDIx is correctly
  *  set, which is forced to MDI mode only.
  **/
-static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw)
+static int32_t e1000_validate_mdi_setting_generic(struct e1000_hw *hw)
 {
-       s32 ret_val = E1000_SUCCESS;
+       int32_t ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_validate_mdi_setting_generic");
+       printd("e1000_validate_mdi_setting_generic");
 
        if (!hw->mac.autoneg && (hw->phy.mdix == 0 || hw->phy.mdix == 3)) {
                DEBUGOUT("Invalid MDI setting detected\n");
index 51acae0..68d88cf 100644 (file)
@@ -26,8 +26,6 @@
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
-
 #ifndef _E1000_MAC_H_
 #define _E1000_MAC_H_
 
@@ -37,58 +35,61 @@ FILE_LICENCE ( GPL2_OR_LATER );
  */
 void e1000_init_mac_ops_generic(struct e1000_hw *hw);
 void e1000_null_mac_generic(struct e1000_hw *hw);
-s32  e1000_null_ops_generic(struct e1000_hw *hw);
-s32  e1000_null_link_info(struct e1000_hw *hw, u16 *s, u16 *d);
+int32_t  e1000_null_ops_generic(struct e1000_hw *hw);
+int32_t  e1000_null_link_info(struct e1000_hw *hw, uint16_t *s, uint16_t *d);
 bool e1000_null_mng_mode(struct e1000_hw *hw);
-void e1000_null_update_mc(struct e1000_hw *hw, u8 *h, u32 a);
-void e1000_null_write_vfta(struct e1000_hw *hw, u32 a, u32 b);
-void e1000_null_mta_set(struct e1000_hw *hw, u32 a);
-void e1000_null_rar_set(struct e1000_hw *hw, u8 *h, u32 a);
-s32  e1000_blink_led_generic(struct e1000_hw *hw);
-s32  e1000_check_for_copper_link_generic(struct e1000_hw *hw);
-s32  e1000_check_for_fiber_link_generic(struct e1000_hw *hw);
-s32  e1000_check_for_serdes_link_generic(struct e1000_hw *hw);
-s32  e1000_cleanup_led_generic(struct e1000_hw *hw);
-s32  e1000_commit_fc_settings_generic(struct e1000_hw *hw);
-s32  e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw);
-s32  e1000_config_fc_after_link_up_generic(struct e1000_hw *hw);
-s32  e1000_disable_pcie_master_generic(struct e1000_hw *hw);
-s32  e1000_force_mac_fc_generic(struct e1000_hw *hw);
-s32  e1000_get_auto_rd_done_generic(struct e1000_hw *hw);
-s32  e1000_get_bus_info_pci_generic(struct e1000_hw *hw);
-s32  e1000_get_bus_info_pcie_generic(struct e1000_hw *hw);
+void e1000_null_update_mc(struct e1000_hw *hw, uint8_t *h, uint32_t a);
+void e1000_null_write_vfta(struct e1000_hw *hw, uint32_t a, uint32_t b);
+void e1000_null_mta_set(struct e1000_hw *hw, uint32_t a);
+void e1000_null_rar_set(struct e1000_hw *hw, uint8_t *h, uint32_t a);
+int32_t  e1000_blink_led_generic(struct e1000_hw *hw);
+int32_t  e1000_check_for_copper_link_generic(struct e1000_hw *hw);
+int32_t  e1000_check_for_fiber_link_generic(struct e1000_hw *hw);
+int32_t  e1000_check_for_serdes_link_generic(struct e1000_hw *hw);
+int32_t  e1000_cleanup_led_generic(struct e1000_hw *hw);
+int32_t  e1000_commit_fc_settings_generic(struct e1000_hw *hw);
+int32_t  e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw);
+int32_t  e1000_config_fc_after_link_up_generic(struct e1000_hw *hw);
+int32_t  e1000_disable_pcie_master_generic(struct e1000_hw *hw);
+int32_t  e1000_force_mac_fc_generic(struct e1000_hw *hw);
+int32_t  e1000_get_auto_rd_done_generic(struct e1000_hw *hw);
+int32_t  e1000_get_bus_info_pci_generic(struct e1000_hw *hw);
+int32_t  e1000_get_bus_info_pcie_generic(struct e1000_hw *hw);
 void e1000_set_lan_id_single_port(struct e1000_hw *hw);
 void e1000_set_lan_id_multi_port_pci(struct e1000_hw *hw);
-s32  e1000_get_hw_semaphore_generic(struct e1000_hw *hw);
-s32  e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, u16 *speed,
-                                               u16 *duplex);
-s32  e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw *hw,
-                                                     u16 *speed, u16 *duplex);
-s32  e1000_id_led_init_generic(struct e1000_hw *hw);
-s32  e1000_led_on_generic(struct e1000_hw *hw);
-s32  e1000_led_off_generic(struct e1000_hw *hw);
+int32_t  e1000_get_hw_semaphore_generic(struct e1000_hw *hw);
+int32_t  e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, uint16_t *speed,
+                                               uint16_t *duplex);
+int32_t  e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw *hw,
+                                                     uint16_t *speed,
+                                                    uint16_t *duplex);
+int32_t  e1000_id_led_init_generic(struct e1000_hw *hw);
+int32_t  e1000_led_on_generic(struct e1000_hw *hw);
+int32_t  e1000_led_off_generic(struct e1000_hw *hw);
 void e1000_update_mc_addr_list_generic(struct e1000_hw *hw,
-                                      u8 *mc_addr_list, u32 mc_addr_count);
-s32  e1000_set_default_fc_generic(struct e1000_hw *hw);
-s32  e1000_set_fc_watermarks_generic(struct e1000_hw *hw);
-s32  e1000_setup_fiber_serdes_link_generic(struct e1000_hw *hw);
-s32  e1000_setup_led_generic(struct e1000_hw *hw);
-s32  e1000_setup_link_generic(struct e1000_hw *hw);
+                                      uint8_t *mc_addr_list,
+                                      uint32_t mc_addr_count);
+int32_t  e1000_set_default_fc_generic(struct e1000_hw *hw);
+int32_t  e1000_set_fc_watermarks_generic(struct e1000_hw *hw);
+int32_t  e1000_setup_fiber_serdes_link_generic(struct e1000_hw *hw);
+int32_t  e1000_setup_led_generic(struct e1000_hw *hw);
+int32_t  e1000_setup_link_generic(struct e1000_hw *hw);
 
-u32  e1000_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr);
+uint32_t  e1000_hash_mc_addr_generic(struct e1000_hw *hw, uint8_t *mc_addr);
 
 void e1000_clear_hw_cntrs_base_generic(struct e1000_hw *hw);
 void e1000_clear_vfta_generic(struct e1000_hw *hw);
 void e1000_config_collision_dist_generic(struct e1000_hw *hw);
-void e1000_init_rx_addrs_generic(struct e1000_hw *hw, u16 rar_count);
-void e1000_mta_set_generic(struct e1000_hw *hw, u32 hash_value);
+void e1000_init_rx_addrs_generic(struct e1000_hw *hw, uint16_t rar_count);
+void e1000_mta_set_generic(struct e1000_hw *hw, uint32_t hash_value);
 void e1000_pcix_mmrbc_workaround_generic(struct e1000_hw *hw);
 void e1000_put_hw_semaphore_generic(struct e1000_hw *hw);
-void e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index);
-s32  e1000_check_alt_mac_addr_generic(struct e1000_hw *hw);
+void e1000_rar_set_generic(struct e1000_hw *hw, uint8_t *addr, uint32_t index);
+int32_t  e1000_check_alt_mac_addr_generic(struct e1000_hw *hw);
 void e1000_reset_adaptive_generic(struct e1000_hw *hw);
-void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, u32 no_snoop);
+void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, uint32_t no_snoop);
 void e1000_update_adaptive_generic(struct e1000_hw *hw);
-void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value);
+void e1000_write_vfta_generic(struct e1000_hw *hw, uint32_t offset,
+                             uint32_t value);
 
 #endif
index 1585417..b9e0d59 100644 (file)
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
 
 #ifndef _E1000_NVM_H_
 #define _E1000_NVM_H_
 
 void e1000_init_nvm_ops_generic(struct e1000_hw *hw);
-s32  e1000_null_read_nvm(struct e1000_hw *hw, u16 a, u16 b, u16 *c);
+int32_t  e1000_null_read_nvm(struct e1000_hw *hw, uint16_t a, uint16_t b,
+                        uint16_t *c);
 void e1000_null_nvm_generic(struct e1000_hw *hw);
-s32  e1000_null_led_default(struct e1000_hw *hw, u16 *data);
-s32  e1000_null_write_nvm(struct e1000_hw *hw, u16 a, u16 b, u16 *c);
-s32  e1000_acquire_nvm_generic(struct e1000_hw *hw);
-
-s32  e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int ee_reg);
-s32  e1000_read_mac_addr_generic(struct e1000_hw *hw);
-s32  e1000_read_pba_num_generic(struct e1000_hw *hw, u32 *pba_num);
-s32  e1000_read_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data);
-s32  e1000_read_nvm_microwire(struct e1000_hw *hw, u16 offset,
-                              u16 words, u16 *data);
-s32  e1000_read_nvm_eerd(struct e1000_hw *hw, u16 offset, u16 words,
-                         u16 *data);
-s32  e1000_valid_led_default_generic(struct e1000_hw *hw, u16 *data);
-s32  e1000_validate_nvm_checksum_generic(struct e1000_hw *hw);
-s32  e1000_write_nvm_eewr(struct e1000_hw *hw, u16 offset,
-                          u16 words, u16 *data);
-s32  e1000_write_nvm_microwire(struct e1000_hw *hw, u16 offset,
-                               u16 words, u16 *data);
-s32  e1000_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words,
-                         u16 *data);
-s32  e1000_update_nvm_checksum_generic(struct e1000_hw *hw);
+int32_t  e1000_null_led_default(struct e1000_hw *hw, uint16_t *data);
+int32_t  e1000_null_write_nvm(struct e1000_hw *hw, uint16_t a, uint16_t b,
+                         uint16_t *c);
+int32_t  e1000_acquire_nvm_generic(struct e1000_hw *hw);
+
+int32_t  e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int ee_reg);
+int32_t  e1000_read_mac_addr_generic(struct e1000_hw *hw);
+int32_t  e1000_read_pba_num_generic(struct e1000_hw *hw, uint32_t *pba_num);
+int32_t  e1000_read_nvm_spi(struct e1000_hw *hw, uint16_t offset, uint16_t words,
+                       uint16_t *data);
+int32_t  e1000_read_nvm_microwire(struct e1000_hw *hw, uint16_t offset,
+                              uint16_t words, uint16_t *data);
+int32_t  e1000_read_nvm_eerd(struct e1000_hw *hw, uint16_t offset, uint16_t words,
+                         uint16_t *data);
+int32_t  e1000_valid_led_default_generic(struct e1000_hw *hw, uint16_t *data);
+int32_t  e1000_validate_nvm_checksum_generic(struct e1000_hw *hw);
+int32_t  e1000_write_nvm_eewr(struct e1000_hw *hw, uint16_t offset,
+                          uint16_t words, uint16_t *data);
+int32_t  e1000_write_nvm_microwire(struct e1000_hw *hw, uint16_t offset,
+                               uint16_t words, uint16_t *data);
+int32_t  e1000_write_nvm_spi(struct e1000_hw *hw, uint16_t offset, uint16_t words,
+                         uint16_t *data);
+int32_t  e1000_update_nvm_checksum_generic(struct e1000_hw *hw);
 void e1000_stop_nvm(struct e1000_hw *hw);
 void e1000_release_nvm_generic(struct e1000_hw *hw);
 
index 5cd8e39..13d3fe6 100644 (file)
@@ -26,8 +26,6 @@
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
-
 /* glue for the OS-dependent part of e1000
  * includes register access macros
  */
@@ -35,9 +33,6 @@ FILE_LICENCE ( GPL2_OR_LATER );
 #ifndef _E1000_OSDEP_H_
 #define _E1000_OSDEP_H_
 
-#define u8         unsigned char
-#define bool       boolean_t
-#define dma_addr_t unsigned long
 #define __le16     uint16_t
 #define __le32     uint32_t
 #define __le64     uint64_t
@@ -46,12 +41,6 @@ FILE_LICENCE ( GPL2_OR_LATER );
 
 #define ETH_FCS_LEN 4
 
-typedef int spinlock_t;
-typedef enum {
-    false = 0,
-    true = 1
-} boolean_t;
-
 #define usec_delay(x) udelay(x)
 #define msec_delay(x) mdelay(x)
 #define msec_delay_irq(x) mdelay(x)
@@ -74,30 +63,25 @@ typedef enum {
                                : e1000_translate_register_82542(reg))
 
 #define E1000_WRITE_REG(a, reg, value) \
-    writel((value), ((a)->hw_addr + E1000_REGISTER(a, reg)))
+    outl((int)((a)->hw_addr + E1000_REGISTER(a, reg)), (value))
 
-#define E1000_READ_REG(a, reg) (readl((a)->hw_addr + E1000_REGISTER(a, reg)))
+#define E1000_READ_REG(a, reg) (inl((a)->hw_addr + E1000_REGISTER(a, reg)))
 
 #define E1000_WRITE_REG_ARRAY(a, reg, offset, value) \
-    writel((value), ((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 2)))
+    outl((int)((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 2)), (value))
 
-#define E1000_READ_REG_ARRAY(a, reg, offset) ( \
-    readl((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 2)))
+#define E1000_READ_REG_ARRAY(a, reg, offset) (inl((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 2)))
 
 #define E1000_READ_REG_ARRAY_DWORD E1000_READ_REG_ARRAY
 #define E1000_WRITE_REG_ARRAY_DWORD E1000_WRITE_REG_ARRAY
 
-#define E1000_WRITE_REG_ARRAY_WORD(a, reg, offset, value) ( \
-    writew((value), ((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 1))))
+#define E1000_WRITE_REG_ARRAY_WORD(a, reg, offset, value) (outw((value), ((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 1))))
 
-#define E1000_READ_REG_ARRAY_WORD(a, reg, offset) ( \
-    readw((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 1)))
+#define E1000_READ_REG_ARRAY_WORD(a, reg, offset) (inw((a)->hw_addr + E1000_REGISTER(a, reg) + ((offset) << 1)))
 
-#define E1000_WRITE_REG_ARRAY_BYTE(a, reg, offset, value) ( \
-    writeb((value), ((a)->hw_addr + E1000_REGISTER(a, reg) + (offset))))
+#define E1000_WRITE_REG_ARRAY_BYTE(a, reg, offset, value) (outb((value), ((a)->hw_addr + E1000_REGISTER(a, reg) + (offset))))
 
-#define E1000_READ_REG_ARRAY_BYTE(a, reg, offset) ( \
-    readb((a)->hw_addr + E1000_REGISTER(a, reg) + (offset)))
+#define E1000_READ_REG_ARRAY_BYTE(a, reg, offset) (inb((a)->hw_addr + E1000_REGISTER(a, reg) + (offset)))
 
 #define E1000_WRITE_REG_IO(a, reg, offset) do { \
     outl(reg, ((a)->io_base));                  \
@@ -105,14 +89,12 @@ typedef enum {
 
 #define E1000_WRITE_FLUSH(a) E1000_READ_REG(a, E1000_STATUS)
 
-#define E1000_WRITE_FLASH_REG(a, reg, value) ( \
-    writel((value), ((a)->flash_address + reg)))
+#define E1000_WRITE_FLASH_REG(a, reg, value) (outl((value), ((a)->flash_address + reg)))
 
-#define E1000_WRITE_FLASH_REG16(a, reg, value) ( \
-    writew((value), ((a)->flash_address + reg)))
+#define E1000_WRITE_FLASH_REG16(a, reg, value) (outw((value), ((a)->flash_address + reg)))
 
-#define E1000_READ_FLASH_REG(a, reg) (readl((a)->flash_address + reg))
+#define E1000_READ_FLASH_REG(a, reg) (inl((a)->flash_address + reg))
 
-#define E1000_READ_FLASH_REG16(a, reg) (readw((a)->flash_address + reg))
+#define E1000_READ_FLASH_REG16(a, reg) (inw((a)->flash_address + reg))
 
 #endif /* _E1000_OSDEP_H_ */
index b3cad48..2da51fe 100644 (file)
@@ -26,7 +26,6 @@
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
 
 #include "e1000_api.h"
 
@@ -61,7 +60,7 @@ static const u16 e1000_igp_2_cable_length_table[] =
 void e1000_init_phy_ops_generic(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
-       DEBUGFUNC("e1000_init_phy_ops_generic");
+       printd("e1000_init_phy_ops_generic");
 
        /* Initialize function pointers */
        phy->ops.init_params = e1000_null_ops_generic;
@@ -91,10 +90,10 @@ void e1000_init_phy_ops_generic(struct e1000_hw *hw)
  *  e1000_null_read_reg - No-op function, return 0
  *  @hw: pointer to the HW structure
  **/
-s32 e1000_null_read_reg(struct e1000_hw *hw __unused, u32 offset __unused,
-                        u16 *data __unused)
+s32 e1000_null_read_reg(struct e1000_hw *hw __unused, uint32_t offset __unused,
+                        uint16_t *data __unused)
 {
-       DEBUGFUNC("e1000_null_read_reg");
+       printd("e1000_null_read_reg");
        return E1000_SUCCESS;
 }
 
@@ -104,7 +103,7 @@ s32 e1000_null_read_reg(struct e1000_hw *hw __unused, u32 offset __unused,
  **/
 void e1000_null_phy_generic(struct e1000_hw *hw __unused)
 {
-       DEBUGFUNC("e1000_null_phy_generic");
+       printd("e1000_null_phy_generic");
        return;
 }
 
@@ -114,7 +113,7 @@ void e1000_null_phy_generic(struct e1000_hw *hw __unused)
  **/
 s32 e1000_null_lplu_state(struct e1000_hw *hw __unused, bool active __unused)
 {
-       DEBUGFUNC("e1000_null_lplu_state");
+       printd("e1000_null_lplu_state");
        return E1000_SUCCESS;
 }
 
@@ -122,10 +121,10 @@ s32 e1000_null_lplu_state(struct e1000_hw *hw __unused, bool active __unused)
  *  e1000_null_write_reg - No-op function, return 0
  *  @hw: pointer to the HW structure
  **/
-s32 e1000_null_write_reg(struct e1000_hw *hw __unused, u32 offset __unused,
-                         u16 data __unused)
+s32 e1000_null_write_reg(struct e1000_hw *hw __unused, uint32_t offset __unused,
+                         uint16_t data __unused)
 {
-       DEBUGFUNC("e1000_null_write_reg");
+       printd("e1000_null_write_reg");
        return E1000_SUCCESS;
 }
 
@@ -139,9 +138,9 @@ s32 e1000_null_write_reg(struct e1000_hw *hw __unused, u32 offset __unused,
  **/
 s32 e1000_check_reset_block_generic(struct e1000_hw *hw)
 {
-       u32 manc;
+       uint32_t manc;
 
-       DEBUGFUNC("e1000_check_reset_block");
+       printd("e1000_check_reset_block");
 
        manc = E1000_READ_REG(hw, E1000_MANC);
 
@@ -160,9 +159,9 @@ s32 e1000_get_phy_id(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val = E1000_SUCCESS;
-       u16 phy_id;
+       uint16_t phy_id;
 
-       DEBUGFUNC("e1000_get_phy_id");
+       printd("e1000_get_phy_id");
 
        if (!(phy->ops.read_reg))
                goto out;
@@ -171,14 +170,14 @@ s32 e1000_get_phy_id(struct e1000_hw *hw)
                if (ret_val)
                        goto out;
 
-               phy->id = (u32)(phy_id << 16);
+               phy->id = (uint32_t)(phy_id << 16);
                usec_delay(20);
                ret_val = phy->ops.read_reg(hw, PHY_ID2, &phy_id);
                if (ret_val)
                        goto out;
 
-               phy->id |= (u32)(phy_id & PHY_REVISION_MASK);
-               phy->revision = (u32)(phy_id & ~PHY_REVISION_MASK);
+               phy->id |= (uint32_t)(phy_id & PHY_REVISION_MASK);
+               phy->revision = (uint32_t)(phy_id & ~PHY_REVISION_MASK);
 
 out:
        return ret_val;
@@ -194,7 +193,7 @@ s32 e1000_phy_reset_dsp_generic(struct e1000_hw *hw)
 {
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_phy_reset_dsp_generic");
+       printd("e1000_phy_reset_dsp_generic");
 
        if (!(hw->phy.ops.write_reg))
                goto out;
@@ -218,13 +217,14 @@ out:
  *  Reads the MDI control register in the PHY at offset and stores the
  *  information read to data.
  **/
-s32 e1000_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data)
+s32 e1000_read_phy_reg_mdic(struct e1000_hw *hw,
+                           uint32_t offset, uint16_t *data)
 {
        struct e1000_phy_info *phy = &hw->phy;
-       u32 i, mdic = 0;
+       uint32_t i, mdic = 0;
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_read_phy_reg_mdic");
+       printd("e1000_read_phy_reg_mdic");
 
        /*
         * Set up Op-code, Phy Address, and register offset in the MDI
@@ -258,7 +258,7 @@ s32 e1000_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data)
                ret_val = -E1000_ERR_PHY;
                goto out;
        }
-       *data = (u16) mdic;
+       *data = (uint16_t) mdic;
 
 out:
        return ret_val;
@@ -272,20 +272,21 @@ out:
  *
  *  Writes data to MDI control register in the PHY at offset.
  **/
-s32 e1000_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data)
+s32 e1000_write_phy_reg_mdic(struct e1000_hw *hw,
+                            uint32_t offset, uint16_t data)
 {
        struct e1000_phy_info *phy = &hw->phy;
-       u32 i, mdic = 0;
+       uint32_t i, mdic = 0;
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_write_phy_reg_mdic");
+       printd("e1000_write_phy_reg_mdic");
 
        /*
         * Set up Op-code, Phy Address, and register offset in the MDI
         * Control register.  The MAC will take care of interfacing with the
         * PHY to retrieve the desired data.
         */
-       mdic = (((u32)data) |
+       mdic = (((uint32_t)data) |
                (offset << E1000_MDIC_REG_SHIFT) |
                (phy->addr << E1000_MDIC_PHY_SHIFT) |
                (E1000_MDIC_OP_WRITE));
@@ -328,11 +329,12 @@ out:
  *  and storing the retrieved information in data.  Release any acquired
  *  semaphores before exiting.
  **/
-s32 e1000_read_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 *data)
+s32 e1000_read_phy_reg_m88(struct e1000_hw *hw,
+                          uint32_t offset, uint16_t *data)
 {
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_read_phy_reg_m88");
+       printd("e1000_read_phy_reg_m88");
 
        if (!(hw->phy.ops.acquire))
                goto out;
@@ -359,11 +361,12 @@ out:
  *  Acquires semaphore, if necessary, then writes the data to PHY register
  *  at the offset.  Release any acquired semaphores before exiting.
  **/
-s32 e1000_write_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 data)
+s32 e1000_write_phy_reg_m88(struct e1000_hw *hw,
+                           uint32_t offset, uint16_t data)
 {
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_write_phy_reg_m88");
+       printd("e1000_write_phy_reg_m88");
 
        if (!(hw->phy.ops.acquire))
                goto out;
@@ -391,11 +394,12 @@ out:
  *  and storing the retrieved information in data.  Release any acquired
  *  semaphores before exiting.
  **/
-s32 e1000_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data)
+s32 e1000_read_phy_reg_igp(struct e1000_hw *hw,
+                          uint32_t offset, uint16_t *data)
 {
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_read_phy_reg_igp");
+       printd("e1000_read_phy_reg_igp");
 
        if (!(hw->phy.ops.acquire))
                goto out;
@@ -407,7 +411,7 @@ s32 e1000_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data)
        if (offset > MAX_PHY_MULTI_PAGE_REG) {
                ret_val = e1000_write_phy_reg_mdic(hw,
                                                   IGP01E1000_PHY_PAGE_SELECT,
-                                                  (u16)offset);
+                                                  (uint16_t)offset);
                if (ret_val) {
                        hw->phy.ops.release(hw);
                        goto out;
@@ -432,11 +436,12 @@ out:
  *  Acquires semaphore, if necessary, then writes the data to PHY register
  *  at the offset.  Release any acquired semaphores before exiting.
  **/
-s32 e1000_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data)
+s32 e1000_write_phy_reg_igp(struct e1000_hw *hw,
+                           uint32_t offset, uint16_t data)
 {
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_write_phy_reg_igp");
+       printd("e1000_write_phy_reg_igp");
 
        if (!(hw->phy.ops.acquire))
                goto out;
@@ -448,7 +453,7 @@ s32 e1000_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data)
        if (offset > MAX_PHY_MULTI_PAGE_REG) {
                ret_val = e1000_write_phy_reg_mdic(hw,
                                                   IGP01E1000_PHY_PAGE_SELECT,
-                                                  (u16)offset);
+                                                  (uint16_t)offset);
                if (ret_val) {
                        hw->phy.ops.release(hw);
                        goto out;
@@ -474,12 +479,13 @@ out:
  *  using the kumeran interface.  The information retrieved is stored in data.
  *  Release any acquired semaphores before exiting.
  **/
-s32 e1000_read_kmrn_reg_generic(struct e1000_hw *hw, u32 offset, u16 *data)
+s32 e1000_read_kmrn_reg_generic(struct e1000_hw *hw, uint32_t offset,
+                               uint16_t *data)
 {
-       u32 kmrnctrlsta;
+       uint32_t kmrnctrlsta;
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_read_kmrn_reg_generic");
+       printd("e1000_read_kmrn_reg_generic");
 
        if (!(hw->phy.ops.acquire))
                goto out;
@@ -495,7 +501,7 @@ s32 e1000_read_kmrn_reg_generic(struct e1000_hw *hw, u32 offset, u16 *data)
        usec_delay(2);
 
        kmrnctrlsta = E1000_READ_REG(hw, E1000_KMRNCTRLSTA);
-       *data = (u16)kmrnctrlsta;
+       *data = (uint16_t)kmrnctrlsta;
 
        hw->phy.ops.release(hw);
 
@@ -513,12 +519,13 @@ out:
  *  at the offset using the kumeran interface.  Release any acquired semaphores
  *  before exiting.
  **/
-s32 e1000_write_kmrn_reg_generic(struct e1000_hw *hw, u32 offset, u16 data)
+s32 e1000_write_kmrn_reg_generic(struct e1000_hw *hw, uint32_t offset,
+                                uint16_t data)
 {
-       u32 kmrnctrlsta;
+       uint32_t kmrnctrlsta;
        s32 ret_val = E1000_SUCCESS;
 
-       DEBUGFUNC("e1000_write_kmrn_reg_generic");
+       printd("e1000_write_kmrn_reg_generic");
 
        if (!(hw->phy.ops.acquire))
                goto out;
@@ -549,9 +556,9 @@ s32 e1000_copper_link_setup_m88(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 phy_data;
+       uint16_t phy_data;
 
-       DEBUGFUNC("e1000_copper_link_setup_m88");
+       printd("e1000_copper_link_setup_m88");
 
        if (phy->reset_disable) {
                ret_val = E1000_SUCCESS;
@@ -658,9 +665,9 @@ s32 e1000_copper_link_setup_igp(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 data;
+       uint16_t data;
 
-       DEBUGFUNC("e1000_copper_link_setup_igp");
+       printd("e1000_copper_link_setup_igp");
 
        if (phy->reset_disable) {
                ret_val = E1000_SUCCESS;
@@ -802,9 +809,9 @@ s32 e1000_copper_link_autoneg(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 phy_ctrl;
+       uint16_t phy_ctrl;
 
-       DEBUGFUNC("e1000_copper_link_autoneg");
+       printd("e1000_copper_link_autoneg");
 
        /*
         * Perform some bounds checking on the autoneg advertisement
@@ -872,10 +879,10 @@ s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 mii_autoneg_adv_reg;
-       u16 mii_1000t_ctrl_reg = 0;
+       uint16_t mii_autoneg_adv_reg;
+       uint16_t mii_1000t_ctrl_reg = 0;
 
-       DEBUGFUNC("e1000_phy_setup_autoneg");
+       printd("e1000_phy_setup_autoneg");
 
        phy->autoneg_advertised &= phy->autoneg_mask;
 
@@ -1039,7 +1046,7 @@ s32 e1000_setup_copper_link_generic(struct e1000_hw *hw)
        s32 ret_val;
        bool link;
 
-       DEBUGFUNC("e1000_setup_copper_link_generic");
+       printd("e1000_setup_copper_link_generic");
 
        if (hw->mac.autoneg) {
                /*
@@ -1423,9 +1430,9 @@ s32 e1000_set_d3_lplu_state_generic(struct e1000_hw *hw, bool active)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val = E1000_SUCCESS;
-       u16 data;
+       uint16_t data;
 
-       DEBUGFUNC("e1000_set_d3_lplu_state_generic");
+       printd("e1000_set_d3_lplu_state_generic");
 
        if (!(hw->phy.ops.read_reg))
                goto out;
@@ -1509,9 +1516,9 @@ s32 e1000_check_downshift_generic(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 phy_data, offset, mask;
+       uint16_t phy_data, offset, mask;
 
-       DEBUGFUNC("e1000_check_downshift_generic");
+       printd("e1000_check_downshift_generic");
 
        switch (phy->type) {
        case e1000_phy_m88:
@@ -1553,9 +1560,9 @@ s32 e1000_check_polarity_m88(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 data;
+       uint16_t data;
 
-       DEBUGFUNC("e1000_check_polarity_m88");
+       printd("e1000_check_polarity_m88");
 
        ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &data);
 
@@ -1580,9 +1587,9 @@ s32 e1000_check_polarity_igp(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 data, offset, mask;
+       uint16_t data, offset, mask;
 
-       DEBUGFUNC("e1000_check_polarity_igp");
+       printd("e1000_check_polarity_igp");
 
        /*
         * Polarity is determined based on the speed of
@@ -1626,9 +1633,9 @@ s32 e1000_check_polarity_ife(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 phy_data, offset, mask;
+       uint16_t phy_data, offset, mask;
 
-       DEBUGFUNC("e1000_check_polarity_ife");
+       printd("e1000_check_polarity_ife");
 
        /*
         * Polarity is determined based on the reversal feature being enabled.
@@ -1661,9 +1668,9 @@ s32 e1000_check_polarity_ife(struct e1000_hw *hw)
 s32 e1000_wait_autoneg_generic(struct e1000_hw *hw)
 {
        s32 ret_val = E1000_SUCCESS;
-       u16 i, phy_status;
+       uint16_t i, phy_status;
 
-       DEBUGFUNC("e1000_wait_autoneg_generic");
+       printd("e1000_wait_autoneg_generic");
 
        if (!(hw->phy.ops.read_reg))
                return E1000_SUCCESS;
@@ -1697,13 +1704,13 @@ s32 e1000_wait_autoneg_generic(struct e1000_hw *hw)
  *
  *  Polls the PHY status register for link, 'iterations' number of times.
  **/
-s32 e1000_phy_has_link_generic(struct e1000_hw *hw, u32 iterations,
-                               u32 usec_interval, bool *success)
+s32 e1000_phy_has_link_generic(struct e1000_hw *hw, uint32_t iterations,
+                               uint32_t usec_interval, bool *success)
 {
        s32 ret_val = E1000_SUCCESS;
-       u16 i, phy_status;
+       uint16_t i, phy_status;
 
-       DEBUGFUNC("e1000_phy_has_link_generic");
+       printd("e1000_phy_has_link_generic");
 
        if (!(hw->phy.ops.read_reg))
                return E1000_SUCCESS;
@@ -1872,10 +1879,10 @@ s32 e1000_get_phy_info_m88(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32  ret_val;
-       u16 phy_data;
+       uint16_t phy_data;
        bool link;
 
-       DEBUGFUNC("e1000_get_phy_info_m88");
+       printd("e1000_get_phy_info_m88");
 
        if (hw->phy.media_type != e1000_media_type_copper) {
                DEBUGOUT("Phy info is only valid for copper media\n");
@@ -1953,10 +1960,10 @@ s32 e1000_get_phy_info_igp(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u16 data;
+       uint16_t data;
        bool link;
 
-       DEBUGFUNC("e1000_get_phy_info_igp");
+       printd("e1000_get_phy_info_igp");
 
        ret_val = e1000_phy_has_link_generic(hw, 1, 0, &link);
        if (ret_val)
@@ -2021,9 +2028,9 @@ out:
 s32 e1000_phy_sw_reset_generic(struct e1000_hw *hw)
 {
        s32 ret_val = E1000_SUCCESS;
-       u16 phy_ctrl;
+       uint16_t phy_ctrl;
 
-       DEBUGFUNC("e1000_phy_sw_reset_generic");
+       printd("e1000_phy_sw_reset_generic");
 
        if (!(hw->phy.ops.read_reg))
                goto out;
@@ -2056,9 +2063,9 @@ s32 e1000_phy_hw_reset_generic(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val = E1000_SUCCESS;
-       u32 ctrl;
+       uint32_t ctrl;
 
-       DEBUGFUNC("e1000_phy_hw_reset_generic");
+       printd("e1000_phy_hw_reset_generic");
 
        ret_val = phy->ops.check_reset_block(hw);
        if (ret_val) {
@@ -2098,7 +2105,7 @@ out:
  **/
 s32 e1000_get_cfg_done_generic(struct e1000_hw *hw __unused)
 {
-       DEBUGFUNC("e1000_get_cfg_done_generic");
+       printd("e1000_get_cfg_done_generic");
 
        msec_delay_irq(10);
 
@@ -2196,7 +2203,7 @@ s32 e1000_phy_init_script_igp3(struct e1000_hw *hw)
  *
  *  Returns the phy type from the id.
  **/
-enum e1000_phy_type e1000_get_phy_type_from_id(u32 phy_id)
+enum e1000_phy_type e1000_get_phy_type_from_id(uint32_t phy_id)
 {
        enum e1000_phy_type phy_type = e1000_phy_unknown;
 
@@ -2239,8 +2246,8 @@ enum e1000_phy_type e1000_get_phy_type_from_id(u32 phy_id)
 s32 e1000_determine_phy_address(struct e1000_hw *hw)
 {
        s32 ret_val = -E1000_ERR_PHY_TYPE;
-       u32 phy_addr = 0;
-       u32 i;
+       uint32_t phy_addr = 0;
+       uint32_t i;
        enum e1000_phy_type phy_type = e1000_phy_unknown;
 
        hw->phy.id = phy_type;
@@ -2280,7 +2287,7 @@ out:
  **/
 void e1000_power_up_phy_copper(struct e1000_hw *hw)
 {
-       u16 mii_reg = 0;
+       uint16_t mii_reg = 0;
 
        /* The PHY will retain its settings across a power down/up cycle */
        hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);
@@ -2298,7 +2305,7 @@ void e1000_power_up_phy_copper(struct e1000_hw *hw)
  **/
 void e1000_power_down_phy_copper(struct e1000_hw *hw)
 {
-       u16 mii_reg = 0;
+       uint16_t mii_reg = 0;
 
        /* The PHY will retain its settings across a power down/up cycle */
        hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);
index 93bd7a1..edc5dd2 100644 (file)
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
 
 #ifndef _E1000_PHY_H_
 #define _E1000_PHY_H_
 
 void e1000_init_phy_ops_generic(struct e1000_hw *hw);
-s32  e1000_null_read_reg(struct e1000_hw *hw, u32 offset, u16 *data);
+s32  e1000_null_read_reg(struct e1000_hw *hw, uint32_t offset, uint16_t *data);
 void e1000_null_phy_generic(struct e1000_hw *hw);
 s32  e1000_null_lplu_state(struct e1000_hw *hw, bool active);
-s32  e1000_null_write_reg(struct e1000_hw *hw, u32 offset, u16 data);
+s32  e1000_null_write_reg(struct e1000_hw *hw, uint32_t offset, uint16_t data);
 s32  e1000_check_downshift_generic(struct e1000_hw *hw);
 s32  e1000_check_polarity_m88(struct e1000_hw *hw);
 s32  e1000_check_polarity_igp(struct e1000_hw *hw);
@@ -64,25 +63,33 @@ void e1000_phy_force_speed_duplex_setup(struct e1000_hw *hw, u16 *phy_ctrl);
 s32  e1000_phy_hw_reset_generic(struct e1000_hw *hw);
 s32  e1000_phy_reset_dsp_generic(struct e1000_hw *hw);
 s32  e1000_phy_setup_autoneg(struct e1000_hw *hw);
-s32  e1000_read_kmrn_reg_generic(struct e1000_hw *hw, u32 offset, u16 *data);
-s32  e1000_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data);
-s32  e1000_read_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 *data);
+s32  e1000_read_kmrn_reg_generic(struct e1000_hw *hw, uint32_t offset,
+                                uint16_t *data);
+s32  e1000_read_phy_reg_igp(struct e1000_hw *hw,
+                           uint32_t offset, uint16_t *data);
+s32  e1000_read_phy_reg_m88(struct e1000_hw *hw,
+                           uint32_t offset, uint16_t *data);
 s32  e1000_set_d3_lplu_state_generic(struct e1000_hw *hw, bool active);
 s32  e1000_setup_copper_link_generic(struct e1000_hw *hw);
 s32  e1000_wait_autoneg_generic(struct e1000_hw *hw);
-s32  e1000_write_kmrn_reg_generic(struct e1000_hw *hw, u32 offset, u16 data);
-s32  e1000_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data);
-s32  e1000_write_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 data);
+s32  e1000_write_kmrn_reg_generic(struct e1000_hw *hw, uint32_t offset,
+                                 uint16_t data);
+s32  e1000_write_phy_reg_igp(struct e1000_hw *hw,
+                            uint32_t offset, uint16_t data);
+s32  e1000_write_phy_reg_m88(struct e1000_hw *hw,
+                            uint32_t offset, uint16_t data);
 s32  e1000_phy_reset_dsp(struct e1000_hw *hw);
-s32  e1000_phy_has_link_generic(struct e1000_hw *hw, u32 iterations,
-                                u32 usec_interval, bool *success);
+s32  e1000_phy_has_link_generic(struct e1000_hw *hw, uint32_t iterations,
+                                uint32_t usec_interval, bool *success);
 s32  e1000_phy_init_script_igp3(struct e1000_hw *hw);
-enum e1000_phy_type e1000_get_phy_type_from_id(u32 phy_id);
+enum e1000_phy_type e1000_get_phy_type_from_id(uint32_t phy_id);
 s32  e1000_determine_phy_address(struct e1000_hw *hw);
 void e1000_power_up_phy_copper(struct e1000_hw *hw);
 void e1000_power_down_phy_copper(struct e1000_hw *hw);
-s32  e1000_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data);
-s32  e1000_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data);
+s32  e1000_read_phy_reg_mdic(struct e1000_hw *hw,
+                            uint32_t offset, uint16_t *data);
+s32  e1000_write_phy_reg_mdic(struct e1000_hw *hw,
+                             uint32_t offset, uint16_t data);
 
 #define E1000_MAX_PHY_ADDR                4
 
index 579c070..0e69e78 100644 (file)
@@ -26,8 +26,6 @@
 
 *******************************************************************************/
 
-FILE_LICENCE ( GPL2_OR_LATER );
-
 #ifndef _E1000_REGS_H_
 #define _E1000_REGS_H_
 
index 260fb08..4b607db 100644 (file)
@@ -2239,7 +2239,7 @@ struct pci_driver rtl8169_driver __pci_driver = {
 
 linker_func_3(ether8169link)
 {
-       addethercard("rtl8169", rtl8169pnp);
+       //addethercard("rtl8169", rtl8169pnp);
 }
 
 /*
index 56984ee..e3d9d7d 100644 (file)
@@ -1,6 +1,7 @@
 #!/bin/sh
 set -e
 # idempotent unless marked otherwise
+sh scripts/etherboot/fixincludes $1
 spatch --sp-file scripts/etherboot/scalar.cocci --in-place $1
 spatch --sp-file scripts/etherboot/func.cocci --in-place $1
 spatch --sp-file scripts/etherboot/io.cocci --in-place $1
index 37941bd..9a7c9f4 100644 (file)
@@ -1,5 +1,11 @@
 @@
 @@
+-DEBUGFUNC(
++printd(
+ ...)
+
+@@
+@@
 -DBGP(
 +printd(
  ...)
index 1417039..7d66d2f 100644 (file)
@@ -19,4 +19,40 @@ typedef uint32_t;
 -u32
 +uint32_t
 
+@@
+typedef u64;
+typedef uint64_t;
+@@
+-u64
++uint64_t
+
+
+@@
+typedef s32;
+typedef int32_t;
+@@
+-s32
++int32_t
+
+
+@@
+typedef __le64;
+@@
+-__le64
++uint64_t
+
+
+@@
+typedef __le32;
+@@
+-__le32
++uint32_t
+
+
+@@
+typedef __le16;
+@@
+-__le16
++uint16_t
+