drivers/sk98lin/skproc.c

   1 /******************************************************************************
   2  *
   3  * Name:    skproc.c
   4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
   5  * Version:     $Revision: 1.4 $
   6  * Date:    $Date: 2003/02/25 14:16:37 $
   7  * Purpose:     Funktions to display statictic data
   8  *
   9  ******************************************************************************/
  10
  11 /******************************************************************************
  12  *
  13  *      (C)Copyright 1998-2003 SysKonnect GmbH.
  14  *
  15  *      This program is free software; you can redistribute it and/or modify
  16  *      it under the terms of the GNU General Public License as published by
  17  *      the Free Software Foundation; either version 2 of the License, or
  18  *      (at your option) any later version.
  19  *
  20  *      Created 22-Nov-2000
  21  *      Author: Mirko Lindner (mlindner@syskonnect.de)
  22  *
  23  *      The information in this file is provided "AS IS" without warranty.
  24  *
  25  ******************************************************************************/
  26 /******************************************************************************
  27  *
  28  * History:
  29  *
  30  *      $Log: skproc.c,v $
  31  *      Revision 1.4  2003/02/25 14:16:37  mlindner
  32  *      Fix: Copyright statement
  33  *
  34  *      Revision 1.3  2002/10/02 12:59:51  mlindner
  35  *      Add: Support for Yukon
  36  *      Add: Speed check and setup
  37  *      Add: Merge source for kernel 2.2.x and 2.4.x
  38  *      Add: Read sensor names directly from VPD
  39  *      Fix: Volt values
  40  *
  41  *      Revision 1.2.2.7  2002/01/14 12:45:15  mlindner
  42  *      Fix: Editorial changes
  43  *
  44  *      Revision 1.2.2.6  2001/12/06 15:26:07  mlindner
  45  *      Fix: Return value of proc_read
  46  *
  47  *      Revision 1.2.2.5  2001/12/06 09:57:39  mlindner
  48  *      New ProcFs entries
  49  *
  50  *      Revision 1.2.2.4  2001/09/05 12:16:02  mlindner
  51  *      Add: New ProcFs entries
  52  *      Fix: Counter Errors (Jumbo == to long errors)
  53  *      Fix: Kernel error compilation
  54  *      Fix: too short counters
  55  *
  56  *      Revision 1.2.2.3  2001/06/25 07:26:26  mlindner
  57  *      Add: More error messages
  58  *
  59  *      Revision 1.2.2.2  2001/03/15 12:50:13  mlindner
  60  *      fix: ProcFS owner protection
  61  *
  62  *      Revision 1.2.2.1  2001/03/12 16:43:48  mlindner
  63  *      chg: 2.4 requirements for procfs
  64  *
  65  *      Revision 1.1  2001/01/22 14:15:31  mlindner
  66  *      added ProcFs functionality
  67  *      Dual Net functionality integrated
  68  *      Rlmt networks added
  69  *
  70  *
  71  ******************************************************************************/
  72
  73 #include <linux/proc_fs.h>
  74
  75 #include "h/skdrv1st.h"
  76 #include "h/skdrv2nd.h"
  77 #define ZEROPAD         1               /* pad with zero */
  78 #define SIGN            2               /* unsigned/signed long */
  79 #define PLUS            4               /* show plus */
  80 #define SPACE           8               /* space if plus */
  81 #define LEFT            16              /* left justified */
  82 #define SPECIALX        32              /* 0x */
  83 #define LARGE           64
  84
  85 extern SK_AC                            *pACList;
  86 extern struct net_device        *SkGeRootDev;
  87
  88 extern char * SkNumber(
  89         char * str,
  90         long long num,
  91         int base,
  92         int size,
  93         int precision,
  94         int type);
  95
  96
  97 /*****************************************************************************
  98  *
  99  *      proc_read - print "summaries" entry
 100  *
 101  * Description:
 102  *  This function fills the proc entry with statistic data about
 103  *  the ethernet device.
 104  *
 105  *
 106  * Returns: buffer with statistic data
 107  *
 108  */
 109 int proc_read(char *buffer,
 110 char **buffer_location,
 111 off_t offset,
 112 int buffer_length,
 113 int *eof,
 114 void *data)
 115 {
 116         int len = 0;
 117         int t;
 118         int i;
 119         DEV_NET                                 *pNet;
 120         SK_AC                                   *pAC;
 121         char                                    test_buf[100];
 122         char                                    sens_msg[50];
 123         unsigned long                   Flags;
 124         unsigned int                    Size;
 125         struct SK_NET_DEVICE            *next;
 126         struct SK_NET_DEVICE            *SkgeProcDev = SkGeRootDev;
 127
 128         SK_PNMI_STRUCT_DATA     *pPnmiStruct;
 129         SK_PNMI_STAT            *pPnmiStat;
 130         struct proc_dir_entry *file = (struct proc_dir_entry*) data;
 131
 132         while (SkgeProcDev) {
 133                 pNet = (DEV_NET*) SkgeProcDev->priv;
 134                 pAC = pNet->pAC;
 135                 next = pAC->Next;
 136                 pPnmiStruct = &pAC->PnmiStruct;
 137                 /* NetIndex in GetStruct is now required, zero is only dummy */
 138
 139                 for (t=pAC->GIni.GIMacsFound; t > 0; t--) {
 140                         if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 1)
 141                                 t--;
 142
 143                         spin_lock_irqsave(&pAC->SlowPathLock, Flags);
 144                         Size = SK_PNMI_STRUCT_SIZE;
 145                         SkPnmiGetStruct(pAC, pAC->IoBase,
 146                                 pPnmiStruct, &Size, t-1);
 147                         spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
 148
 149                         if (strcmp(pAC->dev[t-1]->name, file->name) == 0) {
 150                                 pPnmiStat = &pPnmiStruct->Stat[0];
 151                                 len = sprintf(buffer,
 152                                         "\nDetailed statistic for device %s\n",
 153                                         pAC->dev[t-1]->name);
 154                                 len += sprintf(buffer + len,
 155                                         "=======================================\n");
 156
 157                                 /* Board statistics */
 158                                 len += sprintf(buffer + len,
 159                                         "\nBoard statistics\n\n");
 160                                 len += sprintf(buffer + len,
 161                                         "Active Port                    %c\n",
 162                                         'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt.
 163                                         Net[t-1].PrefPort]->PortNumber);
 164                                 len += sprintf(buffer + len,
 165                                         "Preferred Port                 %c\n",
 166                                         'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt.
 167                                         Net[t-1].PrefPort]->PortNumber);
 168
 169                                 len += sprintf(buffer + len,
 170                                         "Bus speed (MHz)                %d\n",
 171                                         pPnmiStruct->BusSpeed);
 172
 173                                 len += sprintf(buffer + len,
 174                                         "Bus width (Bit)                %d\n",
 175                                         pPnmiStruct->BusWidth);
 176                                 len += sprintf(buffer + len,
 177                                         "Hardware revision              v%d.%d\n",
 178                                         (pAC->GIni.GIPciHwRev >> 4) & 0x0F,
 179                                         pAC->GIni.GIPciHwRev & 0x0F);
 180
 181                                 /* Print sensor informations */
 182                                 for (i=0; i < pAC->I2c.MaxSens; i ++) {
 183                                         /* Check type */
 184                                         switch (pAC->I2c.SenTable[i].SenType) {
 185                                         case 1:
 186                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 187                                                 strcat(sens_msg, " (C)");
 188                                                 len += sprintf(buffer + len,
 189                                                         "%-25s      %d.%02d\n",
 190                                                         sens_msg,
 191                                                         pAC->I2c.SenTable[i].SenValue / 10,
 192                                                         pAC->I2c.SenTable[i].SenValue % 10);
 193
 194                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 195                                                 strcat(sens_msg, " (F)");
 196                                                 len += sprintf(buffer + len,
 197                                                         "%-25s      %d.%02d\n",
 198                                                         sens_msg,
 199                                                         ((((pAC->I2c.SenTable[i].SenValue)
 200                                                         *10)*9)/5 + 3200)/100,
 201                                                         ((((pAC->I2c.SenTable[i].SenValue)
 202                                                         *10)*9)/5 + 3200) % 10);
 203                                                 break;
 204                                         case 2:
 205                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 206                                                 strcat(sens_msg, " (V)");
 207                                                 len += sprintf(buffer + len,
 208                                                         "%-25s      %d.%03d\n",
 209                                                         sens_msg,
 210                                                         pAC->I2c.SenTable[i].SenValue / 1000,
 211                                                         pAC->I2c.SenTable[i].SenValue % 1000);
 212                                                 break;
 213                                         case 3:
 214                                                 strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc);
 215                                                 strcat(sens_msg, " (rpm)");
 216                                                 len += sprintf(buffer + len,
 217                                                         "%-25s      %d\n",
 218                                                         sens_msg,
 219                                                         pAC->I2c.SenTable[i].SenValue);
 220                                                 break;
 221                                         default:
 222                                                 break;
 223                                         }
 224                                 }
 225
 226                                 /*Receive statistics */
 227                                 len += sprintf(buffer + len,
 228                                 "\nReceive statistics\n\n");
 229
 230                                 len += sprintf(buffer + len,
 231                                         "Received bytes                 %s\n",
 232                                         SkNumber(test_buf, pPnmiStat->StatRxOctetsOkCts,
 233                                         10,0,-1,0));
 234                                 len += sprintf(buffer + len,
 235                                         "Received packets               %s\n",
 236                                         SkNumber(test_buf, pPnmiStat->StatRxOkCts,
 237                                         10,0,-1,0));
 238 #if 0
 239                                 if (pAC->GIni.GP[0].PhyType == SK_PHY_XMAC &&
 240                                         pAC->HWRevision < 12) {
 241                                         pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts -
 242                                                 pPnmiStat->StatRxShortsCts;
 243                                         pPnmiStat->StatRxShortsCts = 0;
 244                                 }
 245 #endif
 246                                 if (pNet->Mtu > 1500)
 247                                         pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts -
 248                                                 pPnmiStat->StatRxTooLongCts;
 249
 250                                 len += sprintf(buffer + len,
 251                                         "Receive errors                 %s\n",
 252                                         SkNumber(test_buf, pPnmiStruct->InErrorsCts,
 253                                         10,0,-1,0));
 254                                 len += sprintf(buffer + len,
 255                                         "Receive drops                  %s\n",
 256                                         SkNumber(test_buf, pPnmiStruct->RxNoBufCts,
 257                                         10,0,-1,0));
 258                                 len += sprintf(buffer + len,
 259                                         "Received multicast             %s\n",
 260                                         SkNumber(test_buf, pPnmiStat->StatRxMulticastOkCts,
 261                                         10,0,-1,0));
 262                                 len += sprintf(buffer + len,
 263                                         "Receive error types\n");
 264                                 len += sprintf(buffer + len,
 265                                         "   length                      %s\n",
 266                                         SkNumber(test_buf, pPnmiStat->StatRxRuntCts,
 267                                         10, 0, -1, 0));
 268                                 len += sprintf(buffer + len,
 269                                         "   buffer overflow             %s\n",
 270                                         SkNumber(test_buf, pPnmiStat->StatRxFifoOverflowCts,
 271                                         10, 0, -1, 0));
 272                                 len += sprintf(buffer + len,
 273                                         "   bad crc                     %s\n",
 274                                         SkNumber(test_buf, pPnmiStat->StatRxFcsCts,
 275                                         10, 0, -1, 0));
 276                                 len += sprintf(buffer + len,
 277                                         "   framing                     %s\n",
 278                                         SkNumber(test_buf, pPnmiStat->StatRxFramingCts,
 279                                         10, 0, -1, 0));
 280                                 len += sprintf(buffer + len,
 281                                         "   missed frames               %s\n",
 282                                         SkNumber(test_buf, pPnmiStat->StatRxMissedCts,
 283                                         10, 0, -1, 0));
 284
 285                                 if (pNet->Mtu > 1500)
 286                                         pPnmiStat->StatRxTooLongCts = 0;
 287
 288                                 len += sprintf(buffer + len,
 289                                         "   too long                    %s\n",
 290                                         SkNumber(test_buf, pPnmiStat->StatRxTooLongCts,
 291                                         10, 0, -1, 0));
 292                                 len += sprintf(buffer + len,
 293                                         "   carrier extension           %s\n",
 294                                         SkNumber(test_buf, pPnmiStat->StatRxCextCts,
 295                                         10, 0, -1, 0));
 296                                 len += sprintf(buffer + len,
 297                                         "   too short                   %s\n",
 298                                         SkNumber(test_buf, pPnmiStat->StatRxShortsCts,
 299                                         10, 0, -1, 0));
 300                                 len += sprintf(buffer + len,
 301                                         "   symbol                      %s\n",
 302                                         SkNumber(test_buf, pPnmiStat->StatRxSymbolCts,
 303                                         10, 0, -1, 0));
 304                                 len += sprintf(buffer + len,
 305                                         "   LLC MAC size                %s\n",
 306                                         SkNumber(test_buf, pPnmiStat->StatRxIRLengthCts,
 307                                         10, 0, -1, 0));
 308                                 len += sprintf(buffer + len,
 309                                         "   carrier event               %s\n",
 310                                         SkNumber(test_buf, pPnmiStat->StatRxCarrierCts,
 311                                         10, 0, -1, 0));
 312                                 len += sprintf(buffer + len,
 313                                         "   jabber                      %s\n",
 314                                         SkNumber(test_buf, pPnmiStat->StatRxJabberCts,
 315                                         10, 0, -1, 0));
 316
 317
 318                                 /*Transmit statistics */
 319                                 len += sprintf(buffer + len,
 320                                 "\nTransmit statistics\n\n");
 321
 322                                 len += sprintf(buffer + len,
 323                                         "Transmited bytes               %s\n",
 324                                         SkNumber(test_buf, pPnmiStat->StatTxOctetsOkCts,
 325                                         10,0,-1,0));
 326                                 len += sprintf(buffer + len,
 327                                         "Transmited packets             %s\n",
 328                                         SkNumber(test_buf, pPnmiStat->StatTxOkCts,
 329                                         10,0,-1,0));
 330                                 len += sprintf(buffer + len,
 331                                         "Transmit errors                %s\n",
 332                                         SkNumber(test_buf, pPnmiStat->StatTxSingleCollisionCts,
 333                                         10,0,-1,0));
 334                                 len += sprintf(buffer + len,
 335                                         "Transmit dropped               %s\n",
 336                                         SkNumber(test_buf, pPnmiStruct->TxNoBufCts,
 337                                         10,0,-1,0));
 338                                 len += sprintf(buffer + len,
 339                                         "Transmit collisions            %s\n",
 340                                         SkNumber(test_buf, pPnmiStat->StatTxSingleCollisionCts,
 341                                         10,0,-1,0));
 342                                 len += sprintf(buffer + len,
 343                                         "Transmit errors types\n");
 344                                 len += sprintf(buffer + len,
 345                                         "   excessive collision         %ld\n",
 346                                         pAC->stats.tx_aborted_errors);
 347                                 len += sprintf(buffer + len,
 348                                         "   carrier                     %s\n",
 349                                         SkNumber(test_buf, pPnmiStat->StatTxCarrierCts,
 350                                         10, 0, -1, 0));
 351                                 len += sprintf(buffer + len,
 352                                         "   fifo underrun               %s\n",
 353                                         SkNumber(test_buf, pPnmiStat->StatTxFifoUnderrunCts,
 354                                         10, 0, -1, 0));
 355                                 len += sprintf(buffer + len,
 356                                         "   heartbeat                   %s\n",
 357                                         SkNumber(test_buf, pPnmiStat->StatTxCarrierCts,
 358                                         10, 0, -1, 0));
 359                                 len += sprintf(buffer + len,
 360                                         "   window                      %ld\n",
 361                                         pAC->stats.tx_window_errors);
 362
 363                         }
 364                 }
 365                 SkgeProcDev = next;
 366         }
 367         if (offset >= len) {
 368                 *eof = 1;
 369                 return 0;
 370         }
 371
 372         *buffer_location = buffer + offset;
 373         if (buffer_length >= len - offset) {
 374                 *eof = 1;
 375         }
 376         return (min_t(int, buffer_length, len - offset));
 377 }
 378
 379
 380
 381
 382
 383 /*****************************************************************************
 384  *
 385  * SkDoDiv - convert 64bit number
 386  *
 387  * Description:
 388  *      This function "converts" a long long number.
 389  *
 390  * Returns:
 391  *      remainder of division
 392  */
 393 static long SkDoDiv (long long Dividend, int Divisor, long long *pErg)
 394 {
 395  long           Rest;
 396  long long      Ergebnis;
 397  long           Akku;
 398
 399
 400  Akku  = Dividend >> 32;
 401
 402  Ergebnis = ((long long) (Akku / Divisor)) << 32;
 403  Rest = Akku % Divisor ;
 404
 405  Akku = Rest << 16;
 406  Akku |= ((Dividend & 0xFFFF0000) >> 16);
 407
 408
 409  Ergebnis += ((long long) (Akku / Divisor)) << 16;
 410  Rest = Akku % Divisor ;
 411
 412  Akku = Rest << 16;
 413  Akku |= (Dividend & 0xFFFF);
 414
 415  Ergebnis += (Akku / Divisor);
 416  Rest = Akku % Divisor ;
 417
 418  *pErg = Ergebnis;
 419  return (Rest);
 420 }
 421
 422
 423 #if 0
 424 #define do_div(n,base) ({ \
 425 long long __res; \
 426 __res = ((unsigned long long) n) % (unsigned) base; \
 427 n = ((unsigned long long) n) / (unsigned) base; \
 428 __res; })
 429
 430 #endif
 431
 432
 433 /*****************************************************************************
 434  *
 435  * SkNumber - Print results
 436  *
 437  * Description:
 438  *      This function converts a long long number into a string.
 439  *
 440  * Returns:
 441  *      number as string
 442  */
 443 char * SkNumber(char * str, long long num, int base, int size, int precision
 444         ,int type)
 445 {
 446         char c,sign,tmp[66], *strorg = str;
 447         const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
 448         int i;
 449
 450         if (type & LARGE)
 451                 digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 452         if (type & LEFT)
 453                 type &= ~ZEROPAD;
 454         if (base < 2 || base > 36)
 455                 return 0;
 456         c = (type & ZEROPAD) ? '0' : ' ';
 457         sign = 0;
 458         if (type & SIGN) {
 459                 if (num < 0) {
 460                         sign = '-';
 461                         num = -num;
 462                         size--;
 463                 } else if (type & PLUS) {
 464                         sign = '+';
 465                         size--;
 466                 } else if (type & SPACE) {
 467                         sign = ' ';
 468                         size--;
 469                 }
 470         }
 471         if (type & SPECIALX) {
 472                 if (base == 16)
 473                         size -= 2;
 474                 else if (base == 8)
 475                         size--;
 476         }
 477         i = 0;
 478         if (num == 0)
 479                 tmp[i++]='0';
 480         else while (num != 0)
 481                 tmp[i++] = digits[SkDoDiv(num,base, &num)];
 482
 483         if (i > precision)
 484                 precision = i;
 485         size -= precision;
 486         if (!(type&(ZEROPAD+LEFT)))
 487                 while(size-->0)
 488                         *str++ = ' ';
 489         if (sign)
 490                 *str++ = sign;
 491         if (type & SPECIALX) {
 492                 if (base==8)
 493                         *str++ = '0';
 494                 else if (base==16) {
 495                         *str++ = '0';
 496                         *str++ = digits[33];
 497                 }
 498         }
 499         if (!(type & LEFT))
 500                 while (size-- > 0)
 501                         *str++ = c;
 502         while (i < precision--)
 503                 *str++ = '0';
 504         while (i-- > 0)
 505                 *str++ = tmp[i];
 506         while (size-- > 0)
 507                 *str++ = ' ';
 508
 509         str[0] = '\0';
 510
 511         return strorg;
 512 }
 513
 514
 515