12 files changed, 627 insertions, 43 deletions

diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 3a800e2bc94b..ed709a5d07d7 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -225,6 +225,10 @@ struct be_rx_obj {
         u32 cache_line_barrier[15];
 };
 
+struct be_drv_stats {
+        u8 be_on_die_temperature;
+};
+
 struct be_vf_cfg {
         unsigned char vf_mac_addr[ETH_ALEN];
         u32 vf_if_handle;
@@ -234,6 +238,7 @@ struct be_vf_cfg {
 };
 
 #define BE_INVALID_PMAC_ID              0xffffffff
+
 struct be_adapter {
         struct pci_dev *pdev;
         struct net_device *netdev;
@@ -269,6 +274,7 @@ struct be_adapter {
         u32 big_page_size;      /* Compounded page size shared by rx wrbs */
 
         u8 msix_vec_next_idx;
+        struct be_drv_stats drv_stats;
 
         struct vlan_group *vlan_grp;
         u16 vlans_added;
@@ -281,6 +287,7 @@ struct be_adapter {
         struct be_dma_mem stats_cmd;
         /* Work queue used to perform periodic tasks like getting statistics */
         struct delayed_work work;
+        u16 work_counter;
 
         /* Ethtool knobs and info */
         bool rx_csum;           /* BE card must perform rx-checksumming */
@@ -298,7 +305,7 @@ struct be_adapter {
         u32 rx_fc;              /* Rx flow control */
         u32 tx_fc;              /* Tx flow control */
         bool ue_detected;
-        bool stats_ioctl_sent;
+        bool stats_cmd_sent;
         int link_speed;
         u8 port_type;
         u8 transceiver;
@@ -311,6 +318,8 @@ struct be_adapter {
         struct be_vf_cfg vf_cfg[BE_MAX_VF];
         u8 is_virtfn;
         u32 sli_family;
+        u8 hba_port_num;
+        u16 pvid;
 };
 
 #define be_physfn(adapter) (!adapter->is_virtfn)
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index 619ebc24602e..1822ecdadc7e 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -18,6 +18,9 @@
 #include "be.h"
 #include "be_cmds.h"
 
+/* Must be a power of 2 or else MODULO will BUG_ON */
+static int be_get_temp_freq = 32;
+
 static void be_mcc_notify(struct be_adapter *adapter)
 {
         struct be_queue_info *mccq = &adapter->mcc_obj.q;
@@ -81,7 +84,7 @@ static int be_mcc_compl_process(struct be_adapter *adapter,
                         be_dws_le_to_cpu(&resp->hw_stats,
                                                 sizeof(resp->hw_stats));
                         netdev_stats_update(adapter);
-                        adapter->stats_ioctl_sent = false;
+                        adapter->stats_cmd_sent = false;
                 }
         } else if ((compl_status != MCC_STATUS_NOT_SUPPORTED) &&
                    (compl->tag0 != OPCODE_COMMON_NTWK_MAC_QUERY)) {
@@ -124,6 +127,16 @@ static void be_async_grp5_qos_speed_process(struct be_adapter *adapter,
         }
 }
 
+/*Grp5 PVID evt*/
+static void be_async_grp5_pvid_state_process(struct be_adapter *adapter,
+                struct be_async_event_grp5_pvid_state *evt)
+{
+        if (evt->enabled)
+                adapter->pvid = evt->tag;
+        else
+                adapter->pvid = 0;
+}
+
 static void be_async_grp5_evt_process(struct be_adapter *adapter,
                 u32 trailer, struct be_mcc_compl *evt)
 {
@@ -141,6 +154,10 @@ static void be_async_grp5_evt_process(struct be_adapter *adapter,
                 be_async_grp5_qos_speed_process(adapter,
                 (struct be_async_event_grp5_qos_link_speed *)evt);
         break;
+        case ASYNC_EVENT_PVID_STATE:
+                be_async_grp5_pvid_state_process(adapter,
+                (struct be_async_event_grp5_pvid_state *)evt);
+        break;
         default:
                 dev_warn(&adapter->pdev->dev, "Unknown grp5 event!\n");
                 break;
@@ -1055,6 +1072,9 @@ int be_cmd_get_stats(struct be_adapter *adapter, struct be_dma_mem *nonemb_cmd)
         struct be_sge *sge;
         int status = 0;
 
+        if (MODULO(adapter->work_counter, be_get_temp_freq) == 0)
+                be_cmd_get_die_temperature(adapter);
+
         spin_lock_bh(&adapter->mcc_lock);
 
         wrb = wrb_from_mccq(adapter);
@@ -1075,7 +1095,7 @@ int be_cmd_get_stats(struct be_adapter *adapter, struct be_dma_mem *nonemb_cmd)
         sge->len = cpu_to_le32(nonemb_cmd->size);
 
         be_mcc_notify(adapter);
-        adapter->stats_ioctl_sent = true;
+        adapter->stats_cmd_sent = true;
 
 err:
         spin_unlock_bh(&adapter->mcc_lock);
@@ -1122,6 +1142,44 @@ err:
         return status;
 }
 
+/* Uses synchronous mcc */
+int be_cmd_get_die_temperature(struct be_adapter *adapter)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_cntl_addnl_attribs *req;
+        int status;
+
+        spin_lock_bh(&adapter->mcc_lock);
+
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+        req = embedded_payload(wrb);
+
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0,
+                        OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES);
+
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES, sizeof(*req));
+
+        status = be_mcc_notify_wait(adapter);
+        if (!status) {
+                struct be_cmd_resp_get_cntl_addnl_attribs *resp =
+                                                embedded_payload(wrb);
+                adapter->drv_stats.be_on_die_temperature =
+                                                resp->on_die_temperature;
+        }
+        /* If IOCTL fails once, do not bother issuing it again */
+        else
+                be_get_temp_freq = 0;
+
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+        return status;
+}
+
 /* Uses Mbox */
 int be_cmd_get_fw_ver(struct be_adapter *adapter, char *fw_ver)
 {
@@ -1896,3 +1954,57 @@ err:
         spin_unlock_bh(&adapter->mcc_lock);
         return status;
 }
+
+int be_cmd_get_cntl_attributes(struct be_adapter *adapter)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_cntl_attribs *req;
+        struct be_cmd_resp_cntl_attribs *resp;
+        struct be_sge *sge;
+        int status;
+        int payload_len = max(sizeof(*req), sizeof(*resp));
+        struct mgmt_controller_attrib *attribs;
+        struct be_dma_mem attribs_cmd;
+
+        memset(&attribs_cmd, 0, sizeof(struct be_dma_mem));
+        attribs_cmd.size = sizeof(struct be_cmd_resp_cntl_attribs);
+        attribs_cmd.va = pci_alloc_consistent(adapter->pdev, attribs_cmd.size,
+                                                &attribs_cmd.dma);
+        if (!attribs_cmd.va) {
+                dev_err(&adapter->pdev->dev,
+                                "Memory allocation failure\n");
+                return -ENOMEM;
+        }
+
+        if (mutex_lock_interruptible(&adapter->mbox_lock))
+                return -1;
+
+        wrb = wrb_from_mbox(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+        req = attribs_cmd.va;
+        sge = nonembedded_sgl(wrb);
+
+        be_wrb_hdr_prepare(wrb, payload_len, false, 1,
+                        OPCODE_COMMON_GET_CNTL_ATTRIBUTES);
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                         OPCODE_COMMON_GET_CNTL_ATTRIBUTES, payload_len);
+        sge->pa_hi = cpu_to_le32(upper_32_bits(attribs_cmd.dma));
+        sge->pa_lo = cpu_to_le32(attribs_cmd.dma & 0xFFFFFFFF);
+        sge->len = cpu_to_le32(attribs_cmd.size);
+
+        status = be_mbox_notify_wait(adapter);
+        if (!status) {
+                attribs = (struct mgmt_controller_attrib *)( attribs_cmd.va +
+                                        sizeof(struct be_cmd_resp_hdr));
+                adapter->hba_port_num = attribs->hba_attribs.phy_port;
+        }
+
+err:
+        mutex_unlock(&adapter->mbox_lock);
+        pci_free_consistent(adapter->pdev, attribs_cmd.size, attribs_cmd.va,
+                                        attribs_cmd.dma);
+        return status;
+}
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h
index 91c5d2b09aa1..93e5768fc705 100644
--- a/drivers/net/benet/be_cmds.h
+++ b/drivers/net/benet/be_cmds.h
@@ -88,6 +88,7 @@ struct be_mcc_compl {
 #define ASYNC_EVENT_CODE_GRP_5          0x5
 #define ASYNC_EVENT_QOS_SPEED           0x1
 #define ASYNC_EVENT_COS_PRIORITY        0x2
+#define ASYNC_EVENT_PVID_STATE          0x3
 struct be_async_event_trailer {
         u32 code;
 };
@@ -134,6 +135,18 @@ struct be_async_event_grp5_cos_priority {
         struct be_async_event_trailer trailer;
 } __packed;
 
+/* When the event code of an async trailer is GRP5 and event type is
+ * PVID state, the mcc_compl must be interpreted as follows
+ */
+struct be_async_event_grp5_pvid_state {
+        u8 enabled;
+        u8 rsvd0;
+        u16 tag;
+        u32 event_tag;
+        u32 rsvd1;
+        struct be_async_event_trailer trailer;
+} __packed;
+
 struct be_mcc_mailbox {
         struct be_mcc_wrb wrb;
         struct be_mcc_compl compl;
@@ -156,6 +169,7 @@ struct be_mcc_mailbox {
 #define OPCODE_COMMON_SET_QOS                           28
 #define OPCODE_COMMON_MCC_CREATE_EXT                    90
 #define OPCODE_COMMON_SEEPROM_READ                      30
+#define OPCODE_COMMON_GET_CNTL_ATTRIBUTES               32
 #define OPCODE_COMMON_NTWK_RX_FILTER                    34
 #define OPCODE_COMMON_GET_FW_VERSION                    35
 #define OPCODE_COMMON_SET_FLOW_CONTROL                  36
@@ -176,6 +190,7 @@ struct be_mcc_mailbox {
 #define OPCODE_COMMON_GET_BEACON_STATE                  70
 #define OPCODE_COMMON_READ_TRANSRECV_DATA               73
 #define OPCODE_COMMON_GET_PHY_DETAILS                   102
+#define OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES    121
 
 #define OPCODE_ETH_RSS_CONFIG                           1
 #define OPCODE_ETH_ACPI_CONFIG                          2
@@ -619,7 +634,10 @@ struct be_rxf_stats {
         u32 rx_drops_invalid_ring;      /* dword 145*/
         u32 forwarded_packets;  /* dword 146*/
         u32 rx_drops_mtu;       /* dword 147*/
-        u32 rsvd0[15];
+        u32 rsvd0[7];
+        u32 port0_jabber_events;
+        u32 port1_jabber_events;
+        u32 rsvd1[6];
 };
 
 struct be_erx_stats {
@@ -630,11 +648,16 @@ struct be_erx_stats {
         u32 debug_pmem_pbuf_dealloc;       /* dword 47*/
 };
 
+struct be_pmem_stats {
+        u32 eth_red_drops;
+        u32 rsvd[4];
+};
+
 struct be_hw_stats {
         struct be_rxf_stats rxf;
         u32 rsvd[48];
         struct be_erx_stats erx;
-        u32 rsvd1[6];
+        struct be_pmem_stats pmem;
 };
 
 struct be_cmd_req_get_stats {
@@ -647,6 +670,20 @@ struct be_cmd_resp_get_stats {
         struct be_hw_stats hw_stats;
 };
 
+struct be_cmd_req_get_cntl_addnl_attribs {
+        struct be_cmd_req_hdr hdr;
+        u8 rsvd[8];
+};
+
+struct be_cmd_resp_get_cntl_addnl_attribs {
+        struct be_cmd_resp_hdr hdr;
+        u16 ipl_file_number;
+        u8 ipl_file_version;
+        u8 rsvd0;
+        u8 on_die_temperature; /* in degrees centigrade*/
+        u8 rsvd1[3];
+};
+
 struct be_cmd_req_vlan_config {
         struct be_cmd_req_hdr hdr;
         u8 interface_id;
@@ -994,6 +1031,16 @@ struct be_cmd_resp_set_qos {
         u32 rsvd;
 };
 
+/*********************** Controller Attributes ***********************/
+struct be_cmd_req_cntl_attribs {
+        struct be_cmd_req_hdr hdr;
+};
+
+struct be_cmd_resp_cntl_attribs {
+        struct be_cmd_resp_hdr hdr;
+        struct mgmt_controller_attrib attribs;
+};
+
 extern int be_pci_fnum_get(struct be_adapter *adapter);
 extern int be_cmd_POST(struct be_adapter *adapter);
 extern int be_cmd_mac_addr_query(struct be_adapter *adapter, u8 *mac_addr,
@@ -1078,4 +1125,6 @@ extern int be_cmd_get_phy_info(struct be_adapter *adapter,
                 struct be_dma_mem *cmd);
 extern int be_cmd_set_qos(struct be_adapter *adapter, u32 bps, u32 domain);
 extern void be_detect_dump_ue(struct be_adapter *adapter);
+extern int be_cmd_get_die_temperature(struct be_adapter *adapter);
+extern int be_cmd_get_cntl_attributes(struct be_adapter *adapter);
 
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c
index 07b4ab902b17..6e5e43380c2a 100644
--- a/drivers/net/benet/be_ethtool.c
+++ b/drivers/net/benet/be_ethtool.c
@@ -26,7 +26,8 @@ struct be_ethtool_stat {
         int offset;
 };
 
-enum {NETSTAT, PORTSTAT, MISCSTAT, DRVSTAT_TX, DRVSTAT_RX, ERXSTAT};
+enum {NETSTAT, PORTSTAT, MISCSTAT, DRVSTAT_TX, DRVSTAT_RX, ERXSTAT,
+                        PMEMSTAT, DRVSTAT};
 #define FIELDINFO(_struct, field) FIELD_SIZEOF(_struct, field), \
                                         offsetof(_struct, field)
 #define NETSTAT_INFO(field)     #field, NETSTAT,\
@@ -43,6 +44,11 @@ enum {NETSTAT, PORTSTAT, MISCSTAT, DRVSTAT_TX, DRVSTAT_RX, ERXSTAT};
                                                 field)
 #define ERXSTAT_INFO(field)     #field, ERXSTAT,\
                                         FIELDINFO(struct be_erx_stats, field)
+#define PMEMSTAT_INFO(field)    #field, PMEMSTAT,\
+                                        FIELDINFO(struct be_pmem_stats, field)
+#define DRVSTAT_INFO(field)     #field, DRVSTAT,\
+                                        FIELDINFO(struct be_drv_stats, \
+                                                field)
 
 static const struct be_ethtool_stat et_stats[] = {
         {NETSTAT_INFO(rx_packets)},
@@ -99,7 +105,11 @@ static const struct be_ethtool_stat et_stats[] = {
         {MISCSTAT_INFO(rx_drops_too_many_frags)},
         {MISCSTAT_INFO(rx_drops_invalid_ring)},
         {MISCSTAT_INFO(forwarded_packets)},
-        {MISCSTAT_INFO(rx_drops_mtu)}
+        {MISCSTAT_INFO(rx_drops_mtu)},
+        {MISCSTAT_INFO(port0_jabber_events)},
+        {MISCSTAT_INFO(port1_jabber_events)},
+        {PMEMSTAT_INFO(eth_red_drops)},
+        {DRVSTAT_INFO(be_on_die_temperature)}
 };
 #define ETHTOOL_STATS_NUM ARRAY_SIZE(et_stats)
 
@@ -121,7 +131,7 @@ static const char et_self_tests[][ETH_GSTRING_LEN] = {
         "MAC Loopback test",
         "PHY Loopback test",
         "External Loopback test",
-        "DDR DMA test"
+        "DDR DMA test",
         "Link test"
 };
 
@@ -276,6 +286,12 @@ be_get_ethtool_stats(struct net_device *netdev,
                 case MISCSTAT:
                         p = &hw_stats->rxf;
                         break;
+                case PMEMSTAT:
+                        p = &hw_stats->pmem;
+                        break;
+                case DRVSTAT:
+                        p = &adapter->drv_stats;
+                        break;
                 }
 
                 p = (u8 *)p + et_stats[i].offset;
@@ -497,7 +513,7 @@ be_phys_id(struct net_device *netdev, u32 data)
         int status;
         u32 cur;
 
-        be_cmd_get_beacon_state(adapter, adapter->port_num, &cur);
+        be_cmd_get_beacon_state(adapter, adapter->hba_port_num, &cur);
 
         if (cur == BEACON_STATE_ENABLED)
                 return 0;
@@ -505,12 +521,12 @@ be_phys_id(struct net_device *netdev, u32 data)
         if (data < 2)
                 data = 2;
 
-        status = be_cmd_set_beacon_state(adapter, adapter->port_num, 0, 0,
+        status = be_cmd_set_beacon_state(adapter, adapter->hba_port_num, 0, 0,
                         BEACON_STATE_ENABLED);
         set_current_state(TASK_INTERRUPTIBLE);
         schedule_timeout(data*HZ);
 
-        status = be_cmd_set_beacon_state(adapter, adapter->port_num, 0, 0,
+        status = be_cmd_set_beacon_state(adapter, adapter->hba_port_num, 0, 0,
                         BEACON_STATE_DISABLED);
 
         return status;
@@ -589,12 +605,12 @@ err:
 static u64 be_loopback_test(struct be_adapter *adapter, u8 loopback_type,
                                 u64 *status)
 {
-        be_cmd_set_loopback(adapter, adapter->port_num,
+        be_cmd_set_loopback(adapter, adapter->hba_port_num,
                                 loopback_type, 1);
-        *status = be_cmd_loopback_test(adapter, adapter->port_num,
+        *status = be_cmd_loopback_test(adapter, adapter->hba_port_num,
                                 loopback_type, 1500,
                                 2, 0xabc);
-        be_cmd_set_loopback(adapter, adapter->port_num,
+        be_cmd_set_loopback(adapter, adapter->hba_port_num,
                                 BE_NO_LOOPBACK, 1);
         return *status;
 }
@@ -633,7 +649,8 @@ be_self_test(struct net_device *netdev, struct ethtool_test *test, u64 *data)
                                 &qos_link_speed) != 0) {
                 test->flags |= ETH_TEST_FL_FAILED;
                 data[4] = -1;
-        } else if (mac_speed) {
+        } else if (!mac_speed) {
+                test->flags |= ETH_TEST_FL_FAILED;
                 data[4] = 1;
         }
 }
diff --git a/drivers/net/benet/be_hw.h b/drivers/net/benet/be_hw.h
index 4096d9778234..3f459f76cd1d 100644
--- a/drivers/net/benet/be_hw.h
+++ b/drivers/net/benet/be_hw.h
@@ -327,6 +327,53 @@ struct be_eth_rx_compl {
         u32 dw[4];
 };
 
+struct mgmt_hba_attribs {
+        u8 flashrom_version_string[32];
+        u8 manufacturer_name[32];
+        u32 supported_modes;
+        u32 rsvd0[3];
+        u8 ncsi_ver_string[12];
+        u32 default_extended_timeout;
+        u8 controller_model_number[32];
+        u8 controller_description[64];
+        u8 controller_serial_number[32];
+        u8 ip_version_string[32];
+        u8 firmware_version_string[32];
+        u8 bios_version_string[32];
+        u8 redboot_version_string[32];
+        u8 driver_version_string[32];
+        u8 fw_on_flash_version_string[32];
+        u32 functionalities_supported;
+        u16 max_cdblength;
+        u8 asic_revision;
+        u8 generational_guid[16];
+        u8 hba_port_count;
+        u16 default_link_down_timeout;
+        u8 iscsi_ver_min_max;
+        u8 multifunction_device;
+        u8 cache_valid;
+        u8 hba_status;
+        u8 max_domains_supported;
+        u8 phy_port;
+        u32 firmware_post_status;
+        u32 hba_mtu[8];
+        u32 rsvd1[4];
+};
+
+struct mgmt_controller_attrib {
+        struct mgmt_hba_attribs hba_attribs;
+        u16 pci_vendor_id;
+        u16 pci_device_id;
+        u16 pci_sub_vendor_id;
+        u16 pci_sub_system_id;
+        u8 pci_bus_number;
+        u8 pci_device_number;
+        u8 pci_function_number;
+        u8 interface_type;
+        u64 unique_identifier;
+        u32 rsvd0[5];
+};
+
 struct controller_id {
         u32 vendor;
         u32 device;
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index aad7ea37d589..0bdccb10aac5 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -1047,6 +1047,9 @@ static void be_rx_compl_process(struct be_adapter *adapter,
         if ((adapter->function_mode & 0x400) && !vtm)
                 vlanf = 0;
 
+        if ((adapter->pvid == vlanf) && !adapter->vlan_tag[vlanf])
+                vlanf = 0;
+
         if (unlikely(vlanf)) {
                 if (!adapter->vlan_grp || adapter->vlans_added == 0) {
                         kfree_skb(skb);
@@ -1087,6 +1090,9 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
         if ((adapter->function_mode & 0x400) && !vtm)
                 vlanf = 0;
 
+        if ((adapter->pvid == vlanf) && !adapter->vlan_tag[vlanf])
+                vlanf = 0;
+
         skb = napi_get_frags(&eq_obj->napi);
         if (!skb) {
                 be_rx_compl_discard(adapter, rxo, rxcp);
@@ -1873,7 +1879,7 @@ static void be_worker(struct work_struct *work)
                 goto reschedule;
         }
 
-        if (!adapter->stats_ioctl_sent)
+        if (!adapter->stats_cmd_sent)
                 be_cmd_get_stats(adapter, &adapter->stats_cmd);
 
         be_tx_rate_update(adapter);
@@ -2862,6 +2868,10 @@ static int be_get_config(struct be_adapter *adapter)
         else
                 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
 
+        status = be_cmd_get_cntl_attributes(adapter);
+        if (status)
+                return status;
+
         return 0;
 }
 
diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index 74798bee672e..634c0daeecec 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -983,8 +983,6 @@ static int fec_enet_mii_init(struct platform_device *pdev)
         for (i = 0; i < PHY_MAX_ADDR; i++)
                 fep->mii_bus->irq[i] = PHY_POLL;
 
-        platform_set_drvdata(ndev, fep->mii_bus);
-
         if (mdiobus_register(fep->mii_bus))
                 goto err_out_free_mdio_irq;
 
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index d4e04256730b..35b7bc52a2d1 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -21,6 +21,7 @@
 #include <linux/ethtool.h>
 #include <linux/topology.h>
 #include <linux/gfp.h>
+#include <linux/cpu_rmap.h>
 #include "net_driver.h"
 #include "efx.h"
 #include "nic.h"
@@ -307,6 +308,8 @@ static int efx_poll(struct napi_struct *napi, int budget)
                         channel->irq_mod_score = 0;
                 }
 
+                efx_filter_rfs_expire(channel);
+
                 /* There is no race here; although napi_disable() will
                  * only wait for napi_complete(), this isn't a problem
                  * since efx_channel_processed() will have no effect if
@@ -1175,10 +1178,32 @@ static int efx_wanted_channels(void)
         return count;
 }
 
+static int
+efx_init_rx_cpu_rmap(struct efx_nic *efx, struct msix_entry *xentries)
+{
+#ifdef CONFIG_RFS_ACCEL
+        int i, rc;
+
+        efx->net_dev->rx_cpu_rmap = alloc_irq_cpu_rmap(efx->n_rx_channels);
+        if (!efx->net_dev->rx_cpu_rmap)
+                return -ENOMEM;
+        for (i = 0; i < efx->n_rx_channels; i++) {
+                rc = irq_cpu_rmap_add(efx->net_dev->rx_cpu_rmap,
+                                      xentries[i].vector);
+                if (rc) {
+                        free_irq_cpu_rmap(efx->net_dev->rx_cpu_rmap);
+                        efx->net_dev->rx_cpu_rmap = NULL;
+                        return rc;
+                }
+        }
+#endif
+        return 0;
+}
+
 /* Probe the number and type of interrupts we are able to obtain, and
  * the resulting numbers of channels and RX queues.
  */
-static void efx_probe_interrupts(struct efx_nic *efx)
+static int efx_probe_interrupts(struct efx_nic *efx)
 {
         int max_channels =
                 min_t(int, efx->type->phys_addr_channels, EFX_MAX_CHANNELS);
@@ -1220,6 +1245,11 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                                 efx->n_tx_channels = efx->n_channels;
                                 efx->n_rx_channels = efx->n_channels;
                         }
+                        rc = efx_init_rx_cpu_rmap(efx, xentries);
+                        if (rc) {
+                                pci_disable_msix(efx->pci_dev);
+                                return rc;
+                        }
                         for (i = 0; i < n_channels; i++)
                                 efx_get_channel(efx, i)->irq =
                                         xentries[i].vector;
@@ -1253,6 +1283,8 @@ static void efx_probe_interrupts(struct efx_nic *efx)
                 efx->n_tx_channels = 1;
                 efx->legacy_irq = efx->pci_dev->irq;
         }
+
+        return 0;
 }
 
 static void efx_remove_interrupts(struct efx_nic *efx)
@@ -1289,7 +1321,9 @@ static int efx_probe_nic(struct efx_nic *efx)
 
         /* Determine the number of channels and queues by trying to hook
          * in MSI-X interrupts. */
-        efx_probe_interrupts(efx);
+        rc = efx_probe_interrupts(efx);
+        if (rc)
+                goto fail;
 
         if (efx->n_channels > 1)
                 get_random_bytes(&efx->rx_hash_key, sizeof(efx->rx_hash_key));
@@ -1304,6 +1338,10 @@ static int efx_probe_nic(struct efx_nic *efx)
         efx_init_irq_moderation(efx, tx_irq_mod_usec, rx_irq_mod_usec, true);
 
         return 0;
+
+fail:
+        efx->type->remove(efx);
+        return rc;
 }
 
 static void efx_remove_nic(struct efx_nic *efx)
@@ -1837,6 +1875,9 @@ static const struct net_device_ops efx_netdev_ops = {
         .ndo_poll_controller = efx_netpoll,
 #endif
         .ndo_setup_tc           = efx_setup_tc,
+#ifdef CONFIG_RFS_ACCEL
+        .ndo_rx_flow_steer      = efx_filter_rfs,
+#endif
 };
 
 static void efx_update_name(struct efx_nic *efx)
@@ -2274,6 +2315,10 @@ static void efx_fini_struct(struct efx_nic *efx)
  */
 static void efx_pci_remove_main(struct efx_nic *efx)
 {
+#ifdef CONFIG_RFS_ACCEL
+        free_irq_cpu_rmap(efx->net_dev->rx_cpu_rmap);
+        efx->net_dev->rx_cpu_rmap = NULL;
+#endif
         efx_nic_fini_interrupt(efx);
         efx_fini_channels(efx);
         efx_fini_port(efx);
diff --git a/drivers/net/sfc/efx.h b/drivers/net/sfc/efx.h
index 0cb198a64a63..cbce62b9c996 100644
--- a/drivers/net/sfc/efx.h
+++ b/drivers/net/sfc/efx.h
@@ -76,6 +76,21 @@ extern int efx_filter_remove_filter(struct efx_nic *efx,
                                     struct efx_filter_spec *spec);
 extern void efx_filter_clear_rx(struct efx_nic *efx,
                                 enum efx_filter_priority priority);
+#ifdef CONFIG_RFS_ACCEL
+extern int efx_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
+                          u16 rxq_index, u32 flow_id);
+extern bool __efx_filter_rfs_expire(struct efx_nic *efx, unsigned quota);
+static inline void efx_filter_rfs_expire(struct efx_channel *channel)
+{
+        if (channel->rfs_filters_added >= 60 &&
+            __efx_filter_rfs_expire(channel->efx, 100))
+                channel->rfs_filters_added -= 60;
+}
+#define efx_filter_rfs_enabled() 1
+#else
+static inline void efx_filter_rfs_expire(struct efx_channel *channel) {}
+#define efx_filter_rfs_enabled() 0
+#endif
 
 /* Channels */
 extern void efx_process_channel_now(struct efx_channel *channel);
diff --git a/drivers/net/sfc/filter.c b/drivers/net/sfc/filter.c
index d4722c41c4ce..95a980fd63d5 100644
--- a/drivers/net/sfc/filter.c
+++ b/drivers/net/sfc/filter.c
@@ -8,6 +8,7 @@
  */
 
 #include <linux/in.h>
+#include <net/ip.h>
 #include "efx.h"
 #include "filter.h"
 #include "io.h"
@@ -27,6 +28,10 @@
  */
 #define FILTER_CTL_SRCH_MAX 200
 
+/* Don't try very hard to find space for performance hints, as this is
+ * counter-productive. */
+#define FILTER_CTL_SRCH_HINT_MAX 5
+
 enum efx_filter_table_id {
         EFX_FILTER_TABLE_RX_IP = 0,
         EFX_FILTER_TABLE_RX_MAC,
@@ -47,6 +52,10 @@ struct efx_filter_table {
 struct efx_filter_state {
         spinlock_t      lock;
         struct efx_filter_table table[EFX_FILTER_TABLE_COUNT];
+#ifdef CONFIG_RFS_ACCEL
+        u32             *rps_flow_id;
+        unsigned        rps_expire_index;
+#endif
 };
 
 /* The filter hash function is LFSR polynomial x^16 + x^3 + 1 of a 32-bit
@@ -325,15 +334,16 @@ static int efx_filter_search(struct efx_filter_table *table,
                              struct efx_filter_spec *spec, u32 key,
                              bool for_insert, int *depth_required)
 {
-        unsigned hash, incr, filter_idx, depth;
+        unsigned hash, incr, filter_idx, depth, depth_max;
         struct efx_filter_spec *cmp;
 
         hash = efx_filter_hash(key);
         incr = efx_filter_increment(key);
+        depth_max = (spec->priority <= EFX_FILTER_PRI_HINT ?
+                     FILTER_CTL_SRCH_HINT_MAX : FILTER_CTL_SRCH_MAX);
 
         for (depth = 1, filter_idx = hash & (table->size - 1);
-             depth <= FILTER_CTL_SRCH_MAX &&
-                     test_bit(filter_idx, table->used_bitmap);
+             depth <= depth_max && test_bit(filter_idx, table->used_bitmap);
              ++depth) {
                 cmp = &table->spec[filter_idx];
                 if (efx_filter_equal(spec, cmp))
@@ -342,7 +352,7 @@ static int efx_filter_search(struct efx_filter_table *table,
         }
         if (!for_insert)
                 return -ENOENT;
-        if (depth > FILTER_CTL_SRCH_MAX)
+        if (depth > depth_max)
                 return -EBUSY;
 found:
         *depth_required = depth;
@@ -562,6 +572,13 @@ int efx_probe_filters(struct efx_nic *efx)
         spin_lock_init(&state->lock);
 
         if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0) {
+#ifdef CONFIG_RFS_ACCEL
+                state->rps_flow_id = kcalloc(FR_BZ_RX_FILTER_TBL0_ROWS,
+                                             sizeof(*state->rps_flow_id),
+                                             GFP_KERNEL);
+                if (!state->rps_flow_id)
+                        goto fail;
+#endif
                 table = &state->table[EFX_FILTER_TABLE_RX_IP];
                 table->id = EFX_FILTER_TABLE_RX_IP;
                 table->offset = FR_BZ_RX_FILTER_TBL0;
@@ -607,5 +624,97 @@ void efx_remove_filters(struct efx_nic *efx)
                 kfree(state->table[table_id].used_bitmap);
                 vfree(state->table[table_id].spec);
         }
+#ifdef CONFIG_RFS_ACCEL
+        kfree(state->rps_flow_id);
+#endif
         kfree(state);
 }
+
+#ifdef CONFIG_RFS_ACCEL
+
+int efx_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
+                   u16 rxq_index, u32 flow_id)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        struct efx_channel *channel;
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_spec spec;
+        const struct iphdr *ip;
+        const __be16 *ports;
+        int nhoff;
+        int rc;
+
+        nhoff = skb_network_offset(skb);
+
+        if (skb->protocol != htons(ETH_P_IP))
+                return -EPROTONOSUPPORT;
+
+        /* RFS must validate the IP header length before calling us */
+        EFX_BUG_ON_PARANOID(!pskb_may_pull(skb, nhoff + sizeof(*ip)));
+        ip = (const struct iphdr *)(skb->data + nhoff);
+        if (ip->frag_off & htons(IP_MF | IP_OFFSET))
+                return -EPROTONOSUPPORT;
+        EFX_BUG_ON_PARANOID(!pskb_may_pull(skb, nhoff + 4 * ip->ihl + 4));
+        ports = (const __be16 *)(skb->data + nhoff + 4 * ip->ihl);
+
+        efx_filter_init_rx(&spec, EFX_FILTER_PRI_HINT, 0, rxq_index);
+        rc = efx_filter_set_ipv4_full(&spec, ip->protocol,
+                                      ip->daddr, ports[1], ip->saddr, ports[0]);
+        if (rc)
+                return rc;
+
+        rc = efx_filter_insert_filter(efx, &spec, true);
+        if (rc < 0)
+                return rc;
+
+        /* Remember this so we can check whether to expire the filter later */
+        state->rps_flow_id[rc] = flow_id;
+        channel = efx_get_channel(efx, skb_get_rx_queue(skb));
+        ++channel->rfs_filters_added;
+
+        netif_info(efx, rx_status, efx->net_dev,
+                   "steering %s %pI4:%u:%pI4:%u to queue %u [flow %u filter %d]\n",
+                   (ip->protocol == IPPROTO_TCP) ? "TCP" : "UDP",
+                   &ip->saddr, ntohs(ports[0]), &ip->daddr, ntohs(ports[1]),
+                   rxq_index, flow_id, rc);
+
+        return rc;
+}
+
+bool __efx_filter_rfs_expire(struct efx_nic *efx, unsigned quota)
+{
+        struct efx_filter_state *state = efx->filter_state;
+        struct efx_filter_table *table = &state->table[EFX_FILTER_TABLE_RX_IP];
+        unsigned mask = table->size - 1;
+        unsigned index;
+        unsigned stop;
+
+        if (!spin_trylock_bh(&state->lock))
+                return false;
+
+        index = state->rps_expire_index;
+        stop = (index + quota) & mask;
+
+        while (index != stop) {
+                if (test_bit(index, table->used_bitmap) &&
+                    table->spec[index].priority == EFX_FILTER_PRI_HINT &&
+                    rps_may_expire_flow(efx->net_dev,
+                                        table->spec[index].dmaq_id,
+                                        state->rps_flow_id[index], index)) {
+                        netif_info(efx, rx_status, efx->net_dev,
+                                   "expiring filter %d [flow %u]\n",
+                                   index, state->rps_flow_id[index]);
+                        efx_filter_table_clear_entry(efx, table, index);
+                }
+                index = (index + 1) & mask;
+        }
+
+        state->rps_expire_index = stop;
+        if (table->used == 0)
+                efx_filter_table_reset_search_depth(table);
+
+        spin_unlock_bh(&state->lock);
+        return true;
+}
+
+#endif /* CONFIG_RFS_ACCEL */
diff --git a/drivers/net/sfc/net_driver.h b/drivers/net/sfc/net_driver.h
index 96e22ad34970..15b9068e5b87 100644
--- a/drivers/net/sfc/net_driver.h
+++ b/drivers/net/sfc/net_driver.h
@@ -362,6 +362,9 @@ struct efx_channel {
 
         unsigned int irq_count;
         unsigned int irq_mod_score;
+#ifdef CONFIG_RFS_ACCEL
+        unsigned int rfs_filters_added;
+#endif
 
         int rx_alloc_level;
         int rx_alloc_push_pages;
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index 819c1750e2ab..095e52580884 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -32,10 +32,17 @@
 #include <linux/io.h>
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
+#include <linux/ethtool.h>
 #include <asm/cacheflush.h>
 
 #include "sh_eth.h"
 
+#define SH_ETH_DEF_MSG_ENABLE \
+                (NETIF_MSG_LINK | \
+                NETIF_MSG_TIMER | \
+                NETIF_MSG_RX_ERR| \
+                NETIF_MSG_TX_ERR)
+
 /* There is CPU dependent code */
 #if defined(CONFIG_CPU_SUBTYPE_SH7724)
 #define SH_ETH_RESET_DEFAULT    1
@@ -817,6 +824,20 @@ static int sh_eth_rx(struct net_device *ndev)
         return 0;
 }
 
+static void sh_eth_rcv_snd_disable(u32 ioaddr)
+{
+        /* disable tx and rx */
+        writel(readl(ioaddr + ECMR) &
+                ~(ECMR_RE | ECMR_TE), ioaddr + ECMR);
+}
+
+static void sh_eth_rcv_snd_enable(u32 ioaddr)
+{
+        /* enable tx and rx */
+        writel(readl(ioaddr + ECMR) |
+                (ECMR_RE | ECMR_TE), ioaddr + ECMR);
+}
+
 /* error control function */
 static void sh_eth_error(struct net_device *ndev, int intr_status)
 {
@@ -843,11 +864,9 @@ static void sh_eth_error(struct net_device *ndev, int intr_status)
                                 if (mdp->ether_link_active_low)
                                         link_stat = ~link_stat;
                         }
-                        if (!(link_stat & PHY_ST_LINK)) {
-                                /* Link Down : disable tx and rx */
-                                writel(readl(ioaddr + ECMR) &
-                                          ~(ECMR_RE | ECMR_TE), ioaddr + ECMR);
-                        } else {
+                        if (!(link_stat & PHY_ST_LINK))
+                                sh_eth_rcv_snd_disable(ioaddr);
+                        else {
                                 /* Link Up */
                                 writel(readl(ioaddr + EESIPR) &
                                           ~DMAC_M_ECI, ioaddr + EESIPR);
@@ -857,8 +876,7 @@ static void sh_eth_error(struct net_device *ndev, int intr_status)
                                 writel(readl(ioaddr + EESIPR) |
                                           DMAC_M_ECI, ioaddr + EESIPR);
                                 /* enable tx and rx */
-                                writel(readl(ioaddr + ECMR) |
-                                          (ECMR_RE | ECMR_TE), ioaddr + ECMR);
+                                sh_eth_rcv_snd_enable(ioaddr);
                         }
                 }
         }
@@ -867,6 +885,8 @@ static void sh_eth_error(struct net_device *ndev, int intr_status)
                 /* Write buck end. unused write back interrupt */
                 if (intr_status & EESR_TABT)    /* Transmit Abort int */
                         mdp->stats.tx_aborted_errors++;
+                        if (netif_msg_tx_err(mdp))
+                                dev_err(&ndev->dev, "Transmit Abort\n");
         }
 
         if (intr_status & EESR_RABT) {
@@ -874,14 +894,23 @@ static void sh_eth_error(struct net_device *ndev, int intr_status)
                 if (intr_status & EESR_RFRMER) {
                         /* Receive Frame Overflow int */
                         mdp->stats.rx_frame_errors++;
-                        dev_err(&ndev->dev, "Receive Frame Overflow\n");
+                        if (netif_msg_rx_err(mdp))
+                                dev_err(&ndev->dev, "Receive Abort\n");
                 }
         }
 
-        if (!mdp->cd->no_ade) {
-                if (intr_status & EESR_ADE && intr_status & EESR_TDE &&
-                    intr_status & EESR_TFE)
-                        mdp->stats.tx_fifo_errors++;
+        if (intr_status & EESR_TDE) {
+                /* Transmit Descriptor Empty int */
+                mdp->stats.tx_fifo_errors++;
+                if (netif_msg_tx_err(mdp))
+                        dev_err(&ndev->dev, "Transmit Descriptor Empty\n");
+        }
+
+        if (intr_status & EESR_TFE) {
+                /* FIFO under flow */
+                mdp->stats.tx_fifo_errors++;
+                if (netif_msg_tx_err(mdp))
+                        dev_err(&ndev->dev, "Transmit FIFO Under flow\n");
         }
 
         if (intr_status & EESR_RDE) {
@@ -890,12 +919,22 @@ static void sh_eth_error(struct net_device *ndev, int intr_status)
 
                 if (readl(ioaddr + EDRRR) ^ EDRRR_R)
                         writel(EDRRR_R, ioaddr + EDRRR);
-                dev_err(&ndev->dev, "Receive Descriptor Empty\n");
+                if (netif_msg_rx_err(mdp))
+                        dev_err(&ndev->dev, "Receive Descriptor Empty\n");
         }
+
         if (intr_status & EESR_RFE) {
                 /* Receive FIFO Overflow int */
                 mdp->stats.rx_fifo_errors++;
-                dev_err(&ndev->dev, "Receive FIFO Overflow\n");
+                if (netif_msg_rx_err(mdp))
+                        dev_err(&ndev->dev, "Receive FIFO Overflow\n");
+        }
+
+        if (!mdp->cd->no_ade && (intr_status & EESR_ADE)) {
+                /* Address Error */
+                mdp->stats.tx_fifo_errors++;
+                if (netif_msg_tx_err(mdp))
+                        dev_err(&ndev->dev, "Address Error\n");
         }
 
         mask = EESR_TWB | EESR_TABT | EESR_ADE | EESR_TDE | EESR_TFE;
@@ -1012,7 +1051,7 @@ static void sh_eth_adjust_link(struct net_device *ndev)
                 mdp->duplex = -1;
         }
 
-        if (new_state)
+        if (new_state && netif_msg_link(mdp))
                 phy_print_status(phydev);
 }
 
@@ -1063,6 +1102,132 @@ static int sh_eth_phy_start(struct net_device *ndev)
         return 0;
 }
 
+static int sh_eth_get_settings(struct net_device *ndev,
+                        struct ethtool_cmd *ecmd)
+{
+        struct sh_eth_private *mdp = netdev_priv(ndev);
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&mdp->lock, flags);
+        ret = phy_ethtool_gset(mdp->phydev, ecmd);
+        spin_unlock_irqrestore(&mdp->lock, flags);
+
+        return ret;
+}
+
+static int sh_eth_set_settings(struct net_device *ndev,
+                struct ethtool_cmd *ecmd)
+{
+        struct sh_eth_private *mdp = netdev_priv(ndev);
+        unsigned long flags;
+        int ret;
+        u32 ioaddr = ndev->base_addr;
+
+        spin_lock_irqsave(&mdp->lock, flags);
+
+        /* disable tx and rx */
+        sh_eth_rcv_snd_disable(ioaddr);
+
+        ret = phy_ethtool_sset(mdp->phydev, ecmd);
+        if (ret)
+                goto error_exit;
+
+        if (ecmd->duplex == DUPLEX_FULL)
+                mdp->duplex = 1;
+        else
+                mdp->duplex = 0;
+
+        if (mdp->cd->set_duplex)
+                mdp->cd->set_duplex(ndev);
+
+error_exit:
+        mdelay(1);
+
+        /* enable tx and rx */
+        sh_eth_rcv_snd_enable(ioaddr);
+
+        spin_unlock_irqrestore(&mdp->lock, flags);
+
+        return ret;
+}
+
+static int sh_eth_nway_reset(struct net_device *ndev)
+{
+        struct sh_eth_private *mdp = netdev_priv(ndev);
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&mdp->lock, flags);
+        ret = phy_start_aneg(mdp->phydev);
+        spin_unlock_irqrestore(&mdp->lock, flags);
+
+        return ret;
+}
+
+static u32 sh_eth_get_msglevel(struct net_device *ndev)
+{
+        struct sh_eth_private *mdp = netdev_priv(ndev);
+        return mdp->msg_enable;
+}
+
+static void sh_eth_set_msglevel(struct net_device *ndev, u32 value)
+{
+        struct sh_eth_private *mdp = netdev_priv(ndev);
+        mdp->msg_enable = value;
+}
+
+static const char sh_eth_gstrings_stats[][ETH_GSTRING_LEN] = {
+        "rx_current", "tx_current",
+        "rx_dirty", "tx_dirty",
+};
+#define SH_ETH_STATS_LEN  ARRAY_SIZE(sh_eth_gstrings_stats)
+
+static int sh_eth_get_sset_count(struct net_device *netdev, int sset)
+{
+        switch (sset) {
+        case ETH_SS_STATS:
+                return SH_ETH_STATS_LEN;
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+
+static void sh_eth_get_ethtool_stats(struct net_device *ndev,
+                        struct ethtool_stats *stats, u64 *data)
+{
+        struct sh_eth_private *mdp = netdev_priv(ndev);
+        int i = 0;
+
+        /* device-specific stats */
+        data[i++] = mdp->cur_rx;
+        data[i++] = mdp->cur_tx;
+        data[i++] = mdp->dirty_rx;
+        data[i++] = mdp->dirty_tx;
+}
+
+static void sh_eth_get_strings(struct net_device *ndev, u32 stringset, u8 *data)
+{
+        switch (stringset) {
+        case ETH_SS_STATS:
+                memcpy(data, *sh_eth_gstrings_stats,
+                                        sizeof(sh_eth_gstrings_stats));
+                break;
+        }
+}
+
+static struct ethtool_ops sh_eth_ethtool_ops = {
+        .get_settings   = sh_eth_get_settings,
+        .set_settings   = sh_eth_set_settings,
+        .nway_reset             = sh_eth_nway_reset,
+        .get_msglevel   = sh_eth_get_msglevel,
+        .set_msglevel   = sh_eth_set_msglevel,
+        .get_link               = ethtool_op_get_link,
+        .get_strings    = sh_eth_get_strings,
+        .get_ethtool_stats  = sh_eth_get_ethtool_stats,
+        .get_sset_count     = sh_eth_get_sset_count,
+};
+
 /* network device open function */
 static int sh_eth_open(struct net_device *ndev)
 {
@@ -1073,8 +1238,8 @@ static int sh_eth_open(struct net_device *ndev)
 
         ret = request_irq(ndev->irq, sh_eth_interrupt,
 #if defined(CONFIG_CPU_SUBTYPE_SH7763) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7764) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7757)
+        defined(CONFIG_CPU_SUBTYPE_SH7764) || \
+        defined(CONFIG_CPU_SUBTYPE_SH7757)
                                 IRQF_SHARED,
 #else
                                 0,
@@ -1123,8 +1288,8 @@ static void sh_eth_tx_timeout(struct net_device *ndev)
 
         netif_stop_queue(ndev);
 
-        /* worning message out. */
-        printk(KERN_WARNING "%s: transmit timed out, status %8.8x,"
+        if (netif_msg_timer(mdp))
+                dev_err(&ndev->dev, "%s: transmit timed out, status %8.8x,"
                " resetting...\n", ndev->name, (int)readl(ioaddr + EESR));
 
         /* tx_errors count up */
@@ -1167,6 +1332,8 @@ static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         spin_lock_irqsave(&mdp->lock, flags);
         if ((mdp->cur_tx - mdp->dirty_tx) >= (TX_RING_SIZE - 4)) {
                 if (!sh_eth_txfree(ndev)) {
+                        if (netif_msg_tx_queued(mdp))
+                                dev_warn(&ndev->dev, "TxFD exhausted.\n");
                         netif_stop_queue(ndev);
                         spin_unlock_irqrestore(&mdp->lock, flags);
                         return NETDEV_TX_BUSY;
@@ -1497,8 +1664,11 @@ static int sh_eth_drv_probe(struct platform_device *pdev)
 
         /* set function */
         ndev->netdev_ops = &sh_eth_netdev_ops;
+        SET_ETHTOOL_OPS(ndev, &sh_eth_ethtool_ops);
         ndev->watchdog_timeo = TX_TIMEOUT;
 
+        /* debug message level */
+        mdp->msg_enable = SH_ETH_DEF_MSG_ENABLE;
         mdp->post_rx = POST_RX >> (devno << 1);
         mdp->post_fw = POST_FW >> (devno << 1);