Merge git://git.kernel.org/pub/scm/linux/kernel/git/lethal/sh-2.6
[linux-2.6] / drivers / staging / sxg / sxg_ethtool.c
1 /**************************************************************************
2  *
3  * Copyright (C) 2000-2008 Alacritech, Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above
12  *    copyright notice, this list of conditions and the following
13  *    disclaimer in the documentation and/or other materials provided
14  *    with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY ALACRITECH, INC. ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ALACRITECH, INC. OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
23  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * The views and conclusions contained in the software and documentation
30  * are those of the authors and should not be interpreted as representing
31  * official policies, either expressed or implied, of Alacritech, Inc.
32  *
33  **************************************************************************/
34
35 /*
36  * FILENAME: sxg_ethtool.c
37  *
38  * The ethtool support for SXG driver for Alacritech's 10Gbe products.
39  *
40  * NOTE: This is the standard, non-accelerated version of Alacritech's
41  *       IS-NIC driver.
42  */
43 #include <linux/kernel.h>
44 #include <linux/errno.h>
45 #include <linux/module.h>
46 #include <linux/netdevice.h>
47 #include <linux/etherdevice.h>
48 #include <linux/ethtool.h>
49 #include <linux/skbuff.h>
50 #include <linux/pci.h>
51
52 #include "sxg_os.h"
53 #include "sxghw.h"
54 #include "sxghif.h"
55 #include "sxg.h"
56
57 struct sxg_nic_stats {
58         char stat_string[ETH_GSTRING_LEN];
59         int sizeof_stat;
60         int stat_offset;
61 };
62
63 #define SXG_NIC_STATS(m) sizeof(((struct adapter_t *)0)->m), \
64                                 offsetof(struct adapter_t, m)
65
66 #define USER_VIEWABLE_EEPROM_SIZE       28
67
68 static struct sxg_nic_stats sxg_nic_gstrings_stats[] = {
69         {"xmit_ring_0_full", SXG_NIC_STATS(Stats.XmtZeroFull)},
70
71         /* May be will need in future */
72 /*      {"dumb_xmit_broadcast_packets", SXG_NIC_STATS(Stats.DumbXmtBcastPkts)},
73         {"dumb_xmit_broadcast_bytes", SXG_NIC_STATS(Stats.DumbXmtBcastBytes)},
74         {"dumb_xmit_unicast_packets", SXG_NIC_STATS(Stats.DumbXmtUcastPkts)},
75         {"dumb_xmit_unicast_bytes", SXG_NIC_STATS(Stats.DumbXmtUcastBytes)},
76 */
77         {"xmit_queue_length", SXG_NIC_STATS(Stats.XmtQLen)},
78         {"memory_allocation_failure", SXG_NIC_STATS(Stats.NoMem)},
79         {"Interrupts", SXG_NIC_STATS(Stats.NumInts)},
80         {"false_interrupts", SXG_NIC_STATS(Stats.FalseInts)},
81         {"processed_data_queue_full", SXG_NIC_STATS(Stats.PdqFull)},
82         {"event_ring_full", SXG_NIC_STATS(Stats.EventRingFull)},
83         {"transport_checksum_error", SXG_NIC_STATS(Stats.TransportCsum)},
84         {"transport_underflow_error", SXG_NIC_STATS(Stats.TransportUflow)},
85         {"transport_header_length_error", SXG_NIC_STATS(Stats.TransportHdrLen)},
86         {"network_checksum_error", SXG_NIC_STATS(Stats.NetworkCsum)},
87         {"network_underflow_error", SXG_NIC_STATS(Stats.NetworkUflow)},
88         {"network_header_length_error", SXG_NIC_STATS(Stats.NetworkHdrLen)},
89         {"receive_parity_error", SXG_NIC_STATS(Stats.Parity)},
90         {"link_parity_error", SXG_NIC_STATS(Stats.LinkParity)},
91         {"link/data early_error", SXG_NIC_STATS(Stats.LinkEarly)},
92         {"buffer_overflow_error", SXG_NIC_STATS(Stats.LinkBufOflow)},
93         {"link_code_error", SXG_NIC_STATS(Stats.LinkCode)},
94         {"dribble nibble", SXG_NIC_STATS(Stats.LinkDribble)},
95         {"CRC_error", SXG_NIC_STATS(Stats.LinkCrc)},
96         {"link_overflow_error", SXG_NIC_STATS(Stats.LinkOflow)},
97         {"link_underflow_error", SXG_NIC_STATS(Stats.LinkUflow)},
98
99         /* May be need in future */
100 /*      {"dumb_rcv_broadcast_packets", SXG_NIC_STATS(Stats.DumbRcvBcastPkts)},
101         {"dumb_rcv_broadcast_bytes", SXG_NIC_STATS(Stats.DumbRcvBcastBytes)},
102 */      {"dumb_rcv_multicast_packets", SXG_NIC_STATS(Stats.DumbRcvMcastPkts)},
103         {"dumb_rcv_multicast_bytes", SXG_NIC_STATS(Stats.DumbRcvMcastBytes)},
104 /*      {"dumb_rcv_unicast_packets", SXG_NIC_STATS(Stats.DumbRcvUcastPkts)},
105         {"dumb_rcv_unicast_bytes", SXG_NIC_STATS(Stats.DumbRcvUcastBytes)},
106 */
107         {"no_sgl_buffer", SXG_NIC_STATS(Stats.NoSglBuf)},
108 };
109
110 #define SXG_NIC_STATS_LEN       ARRAY_SIZE(sxg_nic_gstrings_stats)
111
112 static inline void sxg_reg32_write(void __iomem *reg, u32 value, bool flush)
113 {
114         writel(value, reg);
115         if (flush)
116                 mb();
117 }
118
119 static inline void sxg_reg64_write(struct adapter_t *adapter, void __iomem *reg,
120                                    u64 value, u32 cpu)
121 {
122         u32 value_high = (u32) (value >> 32);
123         u32 value_low = (u32) (value & 0x00000000FFFFFFFF);
124         unsigned long flags;
125
126         spin_lock_irqsave(&adapter->Bit64RegLock, flags);
127         writel(value_high, (void __iomem *)(&adapter->UcodeRegs[cpu].Upper));
128         writel(value_low, reg);
129         spin_unlock_irqrestore(&adapter->Bit64RegLock, flags);
130 }
131
132 static void
133 sxg_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
134 {
135         struct adapter_t *adapter = netdev_priv(dev);
136         strncpy(drvinfo->driver, sxg_driver_name, 32);
137         strncpy(drvinfo->version, SXG_DRV_VERSION, 32);
138 //      strncpy(drvinfo->fw_version, SAHARA_UCODE_VERS_STRING, 32);
139         strncpy(drvinfo->bus_info, pci_name(adapter->pcidev), 32);
140         /* TODO : Read the major and minor number of firmware. Is this
141          * from the FLASH/EEPROM or download file ?
142          */
143         /* LINSYS : Check if this is correct or if not find the right value
144          * Also check what is the right EEPROM length : EEPROM_SIZE_XFMR or EEPROM_SIZE_NO_XFMR
145          */
146 }
147
148 static int sxg_nic_set_settings(struct net_device *netdev,
149                               struct ethtool_cmd *ecmd)
150 {
151         /* No settings are applicable as we support only 10Gb/FIBRE_media */
152         return -EOPNOTSUPP;
153 }
154
155 static void
156 sxg_nic_get_strings(struct net_device *netdev, u32 stringset, u8 * data)
157 {
158         int index;
159
160         switch(stringset) {
161         case ETH_SS_TEST:
162                 break;
163         case ETH_SS_STATS:
164                 for (index = 0; index < SXG_NIC_STATS_LEN; index++) {
165                         memcpy(data + index * ETH_GSTRING_LEN,
166                                 sxg_nic_gstrings_stats[index].stat_string,
167                                 ETH_GSTRING_LEN);
168                 }
169                 break;
170         }
171 }
172
173 static void
174 sxg_nic_get_ethtool_stats(struct net_device *netdev,
175                         struct ethtool_stats *stats, u64 * data)
176 {
177         struct adapter_t *adapter = netdev_priv(netdev);
178         int index;
179         for (index = 0; index < SXG_NIC_STATS_LEN; index++) {
180                 char *p = (char *)adapter +
181                                 sxg_nic_gstrings_stats[index].stat_offset;
182                 data[index] = (sxg_nic_gstrings_stats[index].sizeof_stat ==
183                                      sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
184         }
185 }
186
187 static int sxg_nic_get_sset_count(struct net_device *netdev, int sset)
188 {
189         switch (sset) {
190         case ETH_SS_STATS:
191                 return SXG_NIC_STATS_LEN;
192         default:
193                 return -EOPNOTSUPP;
194         }
195 }
196
197 static int sxg_nic_get_settings(struct net_device *netdev,
198                                 struct ethtool_cmd *ecmd)
199 {
200         struct adapter_t *adapter = netdev_priv(netdev);
201
202         ecmd->supported = SUPPORTED_10000baseT_Full;
203         ecmd->autoneg = AUTONEG_ENABLE;         //VSS check This
204         ecmd->transceiver = XCVR_EXTERNAL;      //VSS check This
205
206         /* For Fibre Channel */
207         ecmd->supported |= SUPPORTED_FIBRE;
208         ecmd->advertising = (ADVERTISED_10000baseT_Full |
209                                 ADVERTISED_FIBRE);
210         ecmd->port = PORT_FIBRE;
211
212
213         /* Link Speed */
214         if(adapter->LinkState & SXG_LINK_UP) {
215                 ecmd->speed = SPEED_10000;      //adapter->LinkSpeed;
216                 ecmd->duplex = DUPLEX_FULL;
217         }
218         return 0;
219 }
220
221 static u32 sxg_nic_get_rx_csum(struct net_device *netdev)
222 {
223         struct adapter_t *adapter = netdev_priv(netdev);
224         return ((adapter->flags & SXG_RCV_IP_CSUM_ENABLED) &&
225                  (adapter->flags & SXG_RCV_TCP_CSUM_ENABLED));
226 }
227
228 static int sxg_nic_set_rx_csum(struct net_device *netdev, u32 data)
229 {
230         struct adapter_t *adapter = netdev_priv(netdev);
231         if (data)
232                 adapter->flags |= SXG_RCV_IP_CSUM_ENABLED;
233         else
234                 adapter->flags &= ~SXG_RCV_IP_CSUM_ENABLED;
235         /*
236          * We dont need to write to the card to do checksums.
237          * It does it anyways.
238          */
239         return 0;
240 }
241
242 static int sxg_nic_get_regs_len(struct net_device *dev)
243 {
244         return (SXG_HWREG_MEMSIZE + SXG_UCODEREG_MEMSIZE);
245 }
246
247 static void sxg_nic_get_regs(struct net_device *netdev,
248                         struct ethtool_regs *regs, void *p)
249 {
250         struct adapter_t *adapter = netdev_priv(netdev);
251         struct sxg_hw_regs *HwRegs = adapter->HwRegs;
252         struct sxg_ucode_regs *UcodeRegs = adapter->UcodeRegs;
253         u32 *buff = p;
254
255         memset(p, 0, (sizeof(struct sxg_hw_regs)+sizeof(struct sxg_ucode_regs)));
256         memcpy(buff, HwRegs, sizeof(struct sxg_hw_regs));
257         memcpy((buff+sizeof(struct sxg_hw_regs)), UcodeRegs, sizeof(struct sxg_ucode_regs));
258 }
259
260 static int sxg_nic_get_eeprom_len(struct net_device *netdev)
261 {
262         return (USER_VIEWABLE_EEPROM_SIZE);
263 }
264
265 static int sxg_nic_get_eeprom(struct net_device *netdev,
266                                 struct ethtool_eeprom *eeprom, u8 *bytes)
267 {
268         struct adapter_t *adapter = netdev_priv(netdev);
269         struct sw_cfg_data *data;
270         unsigned long           i, status;
271         dma_addr_t p_addr;
272
273         data = pci_alloc_consistent(adapter->pcidev, sizeof(struct sw_cfg_data),
274                                          &p_addr);
275         if(!data) {
276                 /*
277                  * We cant get even this much memory. Raise a hell
278                  * Get out of here
279                  */
280                 printk(KERN_ERR"%s : Could not allocate memory for reading \
281                                 EEPROM\n", __FUNCTION__);
282                 return -ENOMEM;
283         }
284
285         WRITE_REG(adapter->UcodeRegs[0].ConfigStat, SXG_CFG_TIMEOUT, TRUE);
286         WRITE_REG64(adapter, adapter->UcodeRegs[0].Config, p_addr, 0);
287         for(i=0; i<1000; i++) {
288                 READ_REG(adapter->UcodeRegs[0].ConfigStat, status);
289                 if (status != SXG_CFG_TIMEOUT)
290                         break;
291                 mdelay(1);      /* Do we really need this */
292         }
293
294         memset(bytes, 0, eeprom->len);
295         memcpy(bytes, data->MacAddr[0].MacAddr, sizeof(struct sxg_config_mac));
296         memcpy(bytes+6, data->AtkFru.PartNum, 6);
297         memcpy(bytes+12, data->AtkFru.Revision, 2);
298         memcpy(bytes+14, data->AtkFru.Serial, 14);
299
300         return 0;
301 }
302
303 struct ethtool_ops sxg_nic_ethtool_ops = {
304         .get_settings = sxg_nic_get_settings,
305         .set_settings = sxg_nic_set_settings,
306         .get_drvinfo = sxg_nic_get_drvinfo,
307         .get_regs_len = sxg_nic_get_regs_len,
308         .get_regs = sxg_nic_get_regs,
309         .get_link = ethtool_op_get_link,
310 //      .get_wol = sxg_nic_get_wol,
311         .get_eeprom_len = sxg_nic_get_eeprom_len,
312         .get_eeprom = sxg_nic_get_eeprom,
313 //      .get_pauseparam = sxg_nic_get_pauseparam,
314 //      .set_pauseparam = sxg_nic_set_pauseparam,
315         .set_tx_csum = ethtool_op_set_tx_csum,
316         .get_sg = ethtool_op_get_sg,
317         .set_sg = ethtool_op_set_sg,
318 //      .get_tso = sxg_nic_get_tso,
319 //      .set_tso = sxg_nic_set_tso,
320 //      .self_test = sxg_nic_diag_test,
321         .get_strings = sxg_nic_get_strings,
322         .get_ethtool_stats = sxg_nic_get_ethtool_stats,
323         .get_sset_count = sxg_nic_get_sset_count,
324         .get_rx_csum = sxg_nic_get_rx_csum,
325         .set_rx_csum = sxg_nic_set_rx_csum,
326 //      .get_coalesce = sxg_nic_get_intr_coalesce,
327 //      .set_coalesce = sxg_nic_set_intr_coalesce,
328 };