drivers/net/sk98lin/skproc.c

   1 /******************************************************************************
   2  *
   3  * Name:        skproc.c
   4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
   5  * Purpose:     Funktions to display statictic data
   6  *
   7  ******************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  *      (C)Copyright 1998-2002 SysKonnect GmbH.
  12  *      (C)Copyright 2002-2003 Marvell.
  13  *
  14  *      This program is free software; you can redistribute it and/or modify
  15  *      it under the terms of the GNU General Public License as published by
  16  *      the Free Software Foundation; either version 2 of the License, or
  17  *      (at your option) any later version.
  18  *
  19  *      Created 22-Nov-2000
  20  *      Author: Mirko Lindner (mlindner@syskonnect.de)
  21  *
  22  *      The information in this file is provided "AS IS" without warranty.
  23  *
  24  ******************************************************************************/
  25
  26 #include <linux/proc_fs.h>
  27 #include <linux/seq_file.h>
  28
  29 #include "h/skdrv1st.h"
  30 #include "h/skdrv2nd.h"
  31 #include "h/skversion.h"
  32
  33 extern struct SK_NET_DEVICE *SkGeRootDev;
  34 static int sk_proc_print(void *writePtr, char *format, ...);
  35 static void sk_gen_browse(void *buffer);
  36 int len;
  37
  38 static int sk_seq_show(struct seq_file *seq, void *v);
  39 static int sk_proc_open(struct inode *inode, struct file *file);
  40 struct file_operations sk_proc_fops = {
  41         .owner          = THIS_MODULE,
  42         .open           = sk_proc_open,
  43         .read           = seq_read,
  44         .llseek         = seq_lseek,
  45         .release        = single_release,
  46 };
  47 struct net_device *currDev = NULL;
  48
  49 /*****************************************************************************
  50  *
  51  *      sk_gen_browse -generic  print "summaries" entry
  52  *
  53  * Description:
  54  *  This function fills the proc entry with statistic data about
  55  *  the ethernet device.
  56  *
  57  * Returns: -
  58  *
  59  */
  60 static void sk_gen_browse(void *buffer)
  61 {
  62         struct SK_NET_DEVICE    *SkgeProcDev = SkGeRootDev;
  63         struct SK_NET_DEVICE    *next;
  64         SK_PNMI_STRUCT_DATA     *pPnmiStruct;
  65         SK_PNMI_STAT            *pPnmiStat;
  66         unsigned long           Flags;
  67         unsigned int            Size;
  68         DEV_NET                 *pNet;
  69         SK_AC                   *pAC;
  70         char                    sens_msg[50];
  71         int                     MaxSecurityCount = 0;
  72         int                     t;
  73         int                     i;
  74
  75         while (SkgeProcDev) {
  76                 MaxSecurityCount++;
  77                 if (MaxSecurityCount > 100) {
  78                         printk("Max limit for sk_proc_read security counter!\n");
  79                         return;
  80                 }
  81                 pNet = (DEV_NET*) SkgeProcDev->priv;
  82                 pAC = pNet->pAC;
  83                 next = pAC->Next;
  84                 pPnmiStruct = &pAC->PnmiStruct;
  85                 /* NetIndex in GetStruct is now required, zero is only dummy */
  86
  87                 for (t=pAC->GIni.GIMacsFound; t > 0; t--) {
  88                         if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 1)
  89                                 t--;
  90
  91                         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
  92                         Size = SK_PNMI_STRUCT_SIZE;
  93 #ifdef SK_DIAG_SUPPORT
  94                         if (pAC->BoardLevel == SK_INIT_DATA) {
  95                                 SK_MEMCPY(&(pAC->PnmiStruct), &(pAC->PnmiBackup), sizeof(SK_PNMI_STRUCT_DATA));
  96                                 if (pAC->DiagModeActive == DIAG_NOTACTIVE) {
  97                                         pAC->Pnmi.DiagAttached = SK_DIAG_IDLE;
  98                                 }
  99                         } else {
 100                                 SkPnmiGetStruct(pAC, pAC->IoBase, pPnmiStruct, &Size, t-1);
 101                         }
 102 #else
 103                         SkPnmiGetStruct(pAC, pAC->IoBase,
 104                                 pPnmiStruct, &Size, t-1);
 105 #endif
 106                         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
 107
 108                         if (strcmp(pAC->dev[t-1]->name, currDev->name) == 0) {
 109                                 pPnmiStat = &pPnmiStruct->Stat[0];
 110                                 len = sk_proc_print(buffer,
 111                                         "\nDetailed statistic for device %s\n",
 112                                         pAC->dev[t-1]->name);
 113                                 len += sk_proc_print(buffer,
 114                                         "=======================================\n");
 115
 116                                 /* Board statistics */
 117                                 len += sk_proc_print(buffer,
 118                                         "\nBoard statistics\n\n");
 119                                 len += sk_proc_print(buffer,
 120                                         "Active Port                    %c\n",
 121                                         'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt.
 122                                         Net[t-1].PrefPort]->PortNumber);
 123                                 len += sk_proc_print(buffer,
 124                                         "Preferred Port                 %c\n",
 125                                         'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt.
 126                                         Net[t-1].PrefPort]->PortNumber);
 127
 128                                 len += sk_proc_print(buffer,
 129                                         "Bus speed (MHz)                %d\n",
 130                                         pPnmiStruct->BusSpeed);
 131
 132                                 len += sk_proc_print(buffer,
 133                                         "Bus width (Bit)                %d\n",
 134                                         pPnmiStruct->BusWidth);
 135                                 len += sk_proc_print(buffer,
 136                                         "Driver version                 %s\n",
 137                                         VER_STRING);
 138                                 len += sk_proc_print(buffer,
 139                                         "Hardware revision              v%d.%d\n",
 140                                         (pAC->GIni.GIPciHwRev >> 4) & 0x0F,
 141                                         pAC->GIni.GIPciHwRev & 0x0F);
 142
 143                                 /* Print sensor informations */
 144                                 for (i=0; i < pAC->I2c.MaxSens; i ++) {
 145                                         /* Check type */
 146                                         switch (pAC->I2c.SenTable[i].SenType) {
 147                                         case 1:
 148                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 149                                                 strcat(sens_msg, " (C)");
 150                                                 len += sk_proc_print(buffer,
 151                                                         "%-25s      %d.%02d\n",
 152                                                         sens_msg,
 153                                                         pAC->I2c.SenTable[i].SenValue / 10,
 154                                                         pAC->I2c.SenTable[i].SenValue % 10);
 155
 156                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 157                                                 strcat(sens_msg, " (F)");
 158                                                 len += sk_proc_print(buffer,
 159                                                         "%-25s      %d.%02d\n",
 160                                                         sens_msg,
 161                                                         ((((pAC->I2c.SenTable[i].SenValue)
 162                                                         *10)*9)/5 + 3200)/100,
 163                                                         ((((pAC->I2c.SenTable[i].SenValue)
 164                                                         *10)*9)/5 + 3200) % 10);
 165                                                 break;
 166                                         case 2:
 167                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 168                                                 strcat(sens_msg, " (V)");
 169                                                 len += sk_proc_print(buffer,
 170                                                         "%-25s      %d.%03d\n",
 171                                                         sens_msg,
 172                                                         pAC->I2c.SenTable[i].SenValue / 1000,
 173                                                         pAC->I2c.SenTable[i].SenValue % 1000);
 174                                                 break;
 175                                         case 3:
 176                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 177                                                 strcat(sens_msg, " (rpm)");
 178                                                 len += sk_proc_print(buffer,
 179                                                         "%-25s      %d\n",
 180                                                         sens_msg,
 181                                                         pAC->I2c.SenTable[i].SenValue);
 182                                                 break;
 183                                         default:
 184                                                 break;
 185                                         }
 186                                 }
 187
 188                                 /*Receive statistics */
 189                                 len += sk_proc_print(buffer,
 190                                 "\nReceive statistics\n\n");
 191
 192                                 len += sk_proc_print(buffer,
 193                                         "Received bytes                 %Lu\n",
 194                                         (unsigned long long) pPnmiStat->StatRxOctetsOkCts);
 195                                 len += sk_proc_print(buffer,
 196                                         "Received packets               %Lu\n",
 197                                         (unsigned long long) pPnmiStat->StatRxOkCts);
 198 #if 0
 199                                 if (pAC->GIni.GP[0].PhyType == SK_PHY_XMAC &&
 200                                         pAC->HWRevision < 12) {
 201                                         pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts -
 202                                                 pPnmiStat->StatRxShortsCts;
 203                                         pPnmiStat->StatRxShortsCts = 0;
 204                                 }
 205 #endif
 206                                 if (pNet->Mtu > 1500)
 207                                         pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts -
 208                                                 pPnmiStat->StatRxTooLongCts;
 209
 210                                 len += sk_proc_print(buffer,
 211                                         "Receive errors                 %Lu\n",
 212                                         (unsigned long long) pPnmiStruct->InErrorsCts);
 213                                 len += sk_proc_print(buffer,
 214                                         "Receive dropped                %Lu\n",
 215                                         (unsigned long long) pPnmiStruct->RxNoBufCts);
 216                                 len += sk_proc_print(buffer,
 217                                         "Received multicast             %Lu\n",
 218                                         (unsigned long long) pPnmiStat->StatRxMulticastOkCts);
 219                                 len += sk_proc_print(buffer,
 220                                         "Receive error types\n");
 221                                 len += sk_proc_print(buffer,
 222                                         "   length                      %Lu\n",
 223                                         (unsigned long long) pPnmiStat->StatRxRuntCts);
 224                                 len += sk_proc_print(buffer,
 225                                         "   buffer overflow             %Lu\n",
 226                                         (unsigned long long) pPnmiStat->StatRxFifoOverflowCts);
 227                                 len += sk_proc_print(buffer,
 228                                         "   bad crc                     %Lu\n",
 229                                         (unsigned long long) pPnmiStat->StatRxFcsCts);
 230                                 len += sk_proc_print(buffer,
 231                                         "   framing                     %Lu\n",
 232                                         (unsigned long long) pPnmiStat->StatRxFramingCts);
 233                                 len += sk_proc_print(buffer,
 234                                         "   missed frames               %Lu\n",
 235                                         (unsigned long long) pPnmiStat->StatRxMissedCts);
 236
 237                                 if (pNet->Mtu > 1500)
 238                                         pPnmiStat->StatRxTooLongCts = 0;
 239
 240                                 len += sk_proc_print(buffer,
 241                                         "   too long                    %Lu\n",
 242                                         (unsigned long long) pPnmiStat->StatRxTooLongCts);
 243                                 len += sk_proc_print(buffer,
 244                                         "   carrier extension           %Lu\n",
 245                                         (unsigned long long) pPnmiStat->StatRxCextCts);
 246                                 len += sk_proc_print(buffer,
 247                                         "   too short                   %Lu\n",
 248                                         (unsigned long long) pPnmiStat->StatRxShortsCts);
 249                                 len += sk_proc_print(buffer,
 250                                         "   symbol                      %Lu\n",
 251                                         (unsigned long long) pPnmiStat->StatRxSymbolCts);
 252                                 len += sk_proc_print(buffer,
 253                                         "   LLC MAC size                %Lu\n",
 254                                         (unsigned long long) pPnmiStat->StatRxIRLengthCts);
 255                                 len += sk_proc_print(buffer,
 256                                         "   carrier event               %Lu\n",
 257                                         (unsigned long long) pPnmiStat->StatRxCarrierCts);
 258                                 len += sk_proc_print(buffer,
 259                                         "   jabber                      %Lu\n",
 260                                         (unsigned long long) pPnmiStat->StatRxJabberCts);
 261
 262
 263                                 /*Transmit statistics */
 264                                 len += sk_proc_print(buffer,
 265                                 "\nTransmit statistics\n\n");
 266
 267                                 len += sk_proc_print(buffer,
 268                                         "Transmited bytes               %Lu\n",
 269                                         (unsigned long long) pPnmiStat->StatTxOctetsOkCts);
 270                                 len += sk_proc_print(buffer,
 271                                         "Transmited packets             %Lu\n",
 272                                         (unsigned long long) pPnmiStat->StatTxOkCts);
 273                                 len += sk_proc_print(buffer,
 274                                         "Transmit errors                %Lu\n",
 275                                         (unsigned long long) pPnmiStat->StatTxSingleCollisionCts);
 276                                 len += sk_proc_print(buffer,
 277                                         "Transmit dropped               %Lu\n",
 278                                         (unsigned long long) pPnmiStruct->TxNoBufCts);
 279                                 len += sk_proc_print(buffer,
 280                                         "Transmit collisions            %Lu\n",
 281                                         (unsigned long long) pPnmiStat->StatTxSingleCollisionCts);
 282                                 len += sk_proc_print(buffer,
 283                                         "Transmit error types\n");
 284                                 len += sk_proc_print(buffer,
 285                                         "   excessive collision         %ld\n",
 286                                         pAC->stats.tx_aborted_errors);
 287                                 len += sk_proc_print(buffer,
 288                                         "   carrier                     %Lu\n",
 289                                         (unsigned long long) pPnmiStat->StatTxCarrierCts);
 290                                 len += sk_proc_print(buffer,
 291                                         "   fifo underrun               %Lu\n",
 292                                         (unsigned long long) pPnmiStat->StatTxFifoUnderrunCts);
 293                                 len += sk_proc_print(buffer,
 294                                         "   heartbeat                   %Lu\n",
 295                                         (unsigned long long) pPnmiStat->StatTxCarrierCts);
 296                                 len += sk_proc_print(buffer,
 297                                         "   window                      %ld\n",
 298                                         pAC->stats.tx_window_errors);
 299
 300                         } /* if (strcmp(pACname, currDeviceName) == 0) */
 301                 }
 302                 SkgeProcDev = next;
 303         }
 304 }
 305
 306 /*****************************************************************************
 307  *
 308  *      sk_proc_print -generic line print
 309  *
 310  * Description:
 311  *  This function fills the proc entry with statistic data about
 312  *  the ethernet device.
 313  *
 314  * Returns: number of bytes written
 315  *
 316  */
 317 static int sk_proc_print(void *writePtr, char *format, ...)
 318 {
 319 #define MAX_LEN_SINGLE_LINE 256
 320         char     str[MAX_LEN_SINGLE_LINE];
 321         va_list  a_start;
 322         int      lenght = 0;
 323
 324         struct seq_file *seq = (struct seq_file *) writePtr;
 325
 326         SK_MEMSET(str, 0, MAX_LEN_SINGLE_LINE);
 327
 328         va_start(a_start, format);
 329         vsprintf(str, format, a_start);
 330         va_end(a_start);
 331
 332         lenght = strlen(str);
 333
 334         seq_printf(seq, str);
 335         return lenght;
 336 }
 337
 338 /*****************************************************************************
 339  *
 340  *      sk_seq_show - show proc information of a particular adapter
 341  *
 342  * Description:
 343  *  This function fills the proc entry with statistic data about
 344  *  the ethernet device. It invokes the generic sk_gen_browse() to
 345  *  print out all items one per one.
 346  *
 347  * Returns: number of bytes written
 348  *
 349  */
 350 static int sk_seq_show(struct seq_file *seq, void *v)
 351 {
 352     void *castedBuffer = (void *) seq;
 353     currDev = seq->private;
 354     sk_gen_browse(castedBuffer);
 355     return 0;
 356 }
 357
 358 /*****************************************************************************
 359  *
 360  *      sk_proc_open - register the show function when proc is open'ed
 361  *
 362  * Description:
 363  *  This function is called whenever a sk98lin proc file is queried.
 364  *
 365  * Returns: the return value of single_open()
 366  *
 367  */
 368 static int sk_proc_open(struct inode *inode, struct file *file)
 369 {
 370     return single_open(file, sk_seq_show, PDE(inode)->data);
 371 }
 372
 373 /*******************************************************************************
 374  *
 375  * End of file
 376  *
 377  ******************************************************************************/