git.oblomov.eu Git - linux-2.6/blob - drivers/net/sk98lin/skproc.c

   1 /******************************************************************************
   2  *
   3  * Name:        skproc.c
   4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
   5  * Version:     $Revision: 1.11 $
   6  * Date:        $Date: 2003/12/11 16:03:57 $
   7  * Purpose:     Funktions to display statictic data
   8  *
   9  ******************************************************************************/
  10
  11 /******************************************************************************
  12  *
  13  *      (C)Copyright 1998-2002 SysKonnect GmbH.
  14  *      (C)Copyright 2002-2003 Marvell.
  15  *
  16  *      This program is free software; you can redistribute it and/or modify
  17  *      it under the terms of the GNU General Public License as published by
  18  *      the Free Software Foundation; either version 2 of the License, or
  19  *      (at your option) any later version.
  20  *
  21  *      Created 22-Nov-2000
  22  *      Author: Mirko Lindner (mlindner@syskonnect.de)
  23  *
  24  *      The information in this file is provided "AS IS" without warranty.
  25  *
  26  ******************************************************************************/
  27 #include <linux/proc_fs.h>
  28 #include <linux/seq_file.h>
  29
  30 #include "h/skdrv1st.h"
  31 #include "h/skdrv2nd.h"
  32 #include "h/skversion.h"
  33
  34 static int sk_seq_show(struct seq_file *seq, void *v);
  35 static int sk_proc_open(struct inode *inode, struct file *file);
  36
  37 struct file_operations sk_proc_fops = {
  38         .owner          = THIS_MODULE,
  39         .open           = sk_proc_open,
  40         .read           = seq_read,
  41         .llseek         = seq_lseek,
  42         .release        = single_release,
  43 };
  44
  45
  46 /*****************************************************************************
  47  *
  48  *      sk_seq_show - show proc information of a particular adapter
  49  *
  50  * Description:
  51  *  This function fills the proc entry with statistic data about
  52  *  the ethernet device. It invokes the generic sk_gen_browse() to
  53  *  print out all items one per one.
  54  *
  55  * Returns: 0
  56  *
  57  */
  58 static int sk_seq_show(struct seq_file *seq, void *v)
  59 {
  60         struct net_device *dev = seq->private;
  61         DEV_NET                 *pNet = netdev_priv(dev);
  62         SK_AC                   *pAC = pNet->pAC;
  63         SK_PNMI_STRUCT_DATA     *pPnmiStruct = &pAC->PnmiStruct;
  64         unsigned long           Flags;
  65         unsigned int            Size;
  66         char                    sens_msg[50];
  67         int                     t;
  68         int                     i;
  69
  70         /* NetIndex in GetStruct is now required, zero is only dummy */
  71         for (t=pAC->GIni.GIMacsFound; t > 0; t--) {
  72                 if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 1)
  73                         t--;
  74
  75                 spin_lock_irqsave(&pAC->SlowPathLock, Flags);
  76                 Size = SK_PNMI_STRUCT_SIZE;
  77 #ifdef SK_DIAG_SUPPORT
  78                 if (pAC->BoardLevel == SK_INIT_DATA) {
  79                         SK_MEMCPY(&(pAC->PnmiStruct), &(pAC->PnmiBackup), sizeof(SK_PNMI_STRUCT_DATA));
  80                         if (pAC->DiagModeActive == DIAG_NOTACTIVE) {
  81                                 pAC->Pnmi.DiagAttached = SK_DIAG_IDLE;
  82                         }
  83                 } else {
  84                         SkPnmiGetStruct(pAC, pAC->IoBase, pPnmiStruct, &Size, t-1);
  85                 }
  86 #else
  87                 SkPnmiGetStruct(pAC, pAC->IoBase,
  88                                 pPnmiStruct, &Size, t-1);
  89 #endif
  90                 spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
  91
  92                 if (pAC->dev[t-1] == dev) {
  93                         SK_PNMI_STAT    *pPnmiStat = &pPnmiStruct->Stat[0];
  94
  95                         seq_printf(seq, "\nDetailed statistic for device %s\n",
  96                                       pAC->dev[t-1]->name);
  97                         seq_printf(seq, "=======================================\n");
  98
  99                         /* Board statistics */
 100                         seq_printf(seq, "\nBoard statistics\n\n");
 101                         seq_printf(seq, "Active Port                    %c\n",
 102                                       'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt.
 103                                                                     Net[t-1].PrefPort]->PortNumber);
 104                         seq_printf(seq, "Preferred Port                 %c\n",
 105                                       'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt.
 106                                                                     Net[t-1].PrefPort]->PortNumber);
 107
 108                         seq_printf(seq, "Bus speed (MHz)                %d\n",
 109                                       pPnmiStruct->BusSpeed);
 110
 111                         seq_printf(seq, "Bus width (Bit)                %d\n",
 112                                       pPnmiStruct->BusWidth);
 113                         seq_printf(seq, "Driver version                 %s\n",
 114                                       VER_STRING);
 115                         seq_printf(seq, "Hardware revision              v%d.%d\n",
 116                                       (pAC->GIni.GIPciHwRev >> 4) & 0x0F,
 117                                       pAC->GIni.GIPciHwRev & 0x0F);
 118
 119                         /* Print sensor informations */
 120                         for (i=0; i < pAC->I2c.MaxSens; i ++) {
 121                                 /* Check type */
 122                                 switch (pAC->I2c.SenTable[i].SenType) {
 123                                 case 1:
 124                                         strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 125                                         strcat(sens_msg, " (C)");
 126                                         seq_printf(seq, "%-25s      %d.%02d\n",
 127                                                       sens_msg,
 128                                                       pAC->I2c.SenTable[i].SenValue / 10,
 129                                                       pAC->I2c.SenTable[i].SenValue % 10);
 130
 131                                         strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 132                                         strcat(sens_msg, " (F)");
 133                                         seq_printf(seq, "%-25s      %d.%02d\n",
 134                                                       sens_msg,
 135                                                       ((((pAC->I2c.SenTable[i].SenValue)
 136                                                          *10)*9)/5 + 3200)/100,
 137                                                       ((((pAC->I2c.SenTable[i].SenValue)
 138                                                          *10)*9)/5 + 3200) % 10);
 139                                         break;
 140                                 case 2:
 141                                         strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 142                                         strcat(sens_msg, " (V)");
 143                                         seq_printf(seq, "%-25s      %d.%03d\n",
 144                                                       sens_msg,
 145                                                       pAC->I2c.SenTable[i].SenValue / 1000,
 146                                                       pAC->I2c.SenTable[i].SenValue % 1000);
 147                                         break;
 148                                 case 3:
 149                                         strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 150                                         strcat(sens_msg, " (rpm)");
 151                                         seq_printf(seq, "%-25s      %d\n",
 152                                                       sens_msg,
 153                                                       pAC->I2c.SenTable[i].SenValue);
 154                                         break;
 155                                 default:
 156                                         break;
 157                                 }
 158                         }
 159
 160                         /*Receive statistics */
 161                         seq_printf(seq, "\nReceive statistics\n\n");
 162
 163                         seq_printf(seq, "Received bytes                 %Lu\n",
 164                                       (unsigned long long) pPnmiStat->StatRxOctetsOkCts);
 165                         seq_printf(seq, "Received packets               %Lu\n",
 166                                       (unsigned long long) pPnmiStat->StatRxOkCts);
 167 #if 0
 168                         if (pAC->GIni.GP[0].PhyType == SK_PHY_XMAC &&
 169                             pAC->HWRevision < 12) {
 170                                 pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts -
 171                                         pPnmiStat->StatRxShortsCts;
 172                                 pPnmiStat->StatRxShortsCts = 0;
 173                         }
 174 #endif
 175                         if (dev->mtu > 1500)
 176                                 pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts -
 177                                         pPnmiStat->StatRxTooLongCts;
 178
 179                         seq_printf(seq, "Receive errors                 %Lu\n",
 180                                       (unsigned long long) pPnmiStruct->InErrorsCts);
 181                         seq_printf(seq, "Receive dropped                %Lu\n",
 182                                       (unsigned long long) pPnmiStruct->RxNoBufCts);
 183                         seq_printf(seq, "Received multicast             %Lu\n",
 184                                       (unsigned long long) pPnmiStat->StatRxMulticastOkCts);
 185                         seq_printf(seq, "Receive error types\n");
 186                         seq_printf(seq, "   length                      %Lu\n",
 187                                       (unsigned long long) pPnmiStat->StatRxRuntCts);
 188                         seq_printf(seq, "   buffer overflow             %Lu\n",
 189                                       (unsigned long long) pPnmiStat->StatRxFifoOverflowCts);
 190                         seq_printf(seq, "   bad crc                     %Lu\n",
 191                                       (unsigned long long) pPnmiStat->StatRxFcsCts);
 192                         seq_printf(seq, "   framing                     %Lu\n",
 193                                       (unsigned long long) pPnmiStat->StatRxFramingCts);
 194                         seq_printf(seq, "   missed frames               %Lu\n",
 195                                       (unsigned long long) pPnmiStat->StatRxMissedCts);
 196
 197                         if (dev->mtu > 1500)
 198                                 pPnmiStat->StatRxTooLongCts = 0;
 199
 200                         seq_printf(seq, "   too long                    %Lu\n",
 201                                       (unsigned long long) pPnmiStat->StatRxTooLongCts);
 202                         seq_printf(seq, "   carrier extension           %Lu\n",
 203                                       (unsigned long long) pPnmiStat->StatRxCextCts);
 204                         seq_printf(seq, "   too short                   %Lu\n",
 205                                       (unsigned long long) pPnmiStat->StatRxShortsCts);
 206                         seq_printf(seq, "   symbol                      %Lu\n",
 207                                       (unsigned long long) pPnmiStat->StatRxSymbolCts);
 208                         seq_printf(seq, "   LLC MAC size                %Lu\n",
 209                                       (unsigned long long) pPnmiStat->StatRxIRLengthCts);
 210                         seq_printf(seq, "   carrier event               %Lu\n",
 211                                       (unsigned long long) pPnmiStat->StatRxCarrierCts);
 212                         seq_printf(seq, "   jabber                      %Lu\n",
 213                                       (unsigned long long) pPnmiStat->StatRxJabberCts);
 214
 215
 216                         /*Transmit statistics */
 217                         seq_printf(seq, "\nTransmit statistics\n\n");
 218
 219                         seq_printf(seq, "Transmited bytes               %Lu\n",
 220                                       (unsigned long long) pPnmiStat->StatTxOctetsOkCts);
 221                         seq_printf(seq, "Transmited packets             %Lu\n",
 222                                       (unsigned long long) pPnmiStat->StatTxOkCts);
 223                         seq_printf(seq, "Transmit errors                %Lu\n",
 224                                       (unsigned long long) pPnmiStat->StatTxSingleCollisionCts);
 225                         seq_printf(seq, "Transmit dropped               %Lu\n",
 226                                       (unsigned long long) pPnmiStruct->TxNoBufCts);
 227                         seq_printf(seq, "Transmit collisions            %Lu\n",
 228                                       (unsigned long long) pPnmiStat->StatTxSingleCollisionCts);
 229                         seq_printf(seq, "Transmit error types\n");
 230                         seq_printf(seq, "   excessive collision         %ld\n",
 231                                       pAC->stats.tx_aborted_errors);
 232                         seq_printf(seq, "   carrier                     %Lu\n",
 233                                       (unsigned long long) pPnmiStat->StatTxCarrierCts);
 234                         seq_printf(seq, "   fifo underrun               %Lu\n",
 235                                       (unsigned long long) pPnmiStat->StatTxFifoUnderrunCts);
 236                         seq_printf(seq, "   heartbeat                   %Lu\n",
 237                                       (unsigned long long) pPnmiStat->StatTxCarrierCts);
 238                         seq_printf(seq, "   window                      %ld\n",
 239                                       pAC->stats.tx_window_errors);
 240
 241                 }
 242         }
 243         return 0;
 244 }
 245
 246 /*****************************************************************************
 247  *
 248  *      sk_proc_open - register the show function when proc is open'ed
 249  *
 250  * Description:
 251  *  This function is called whenever a sk98lin proc file is queried.
 252  *
 253  * Returns: the return value of single_open()
 254  *
 255  */
 256 static int sk_proc_open(struct inode *inode, struct file *file)
 257 {
 258     return single_open(file, sk_seq_show, PDE(inode)->data);
 259 }
 260
 261 /*******************************************************************************
 262  *
 263  * End of file
 264  *
 265  ******************************************************************************/