tools/tools/nxge/xge_info.c

   1 /*-
   2  * Copyright (c) 2002-2007 Neterion, Inc.
   3  * 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  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28 /******************************************
  29  *  xge_info.c
  30  *
  31  *  To get the Tx, Rx, PCI, Interrupt statistics,
  32  *  PCI configuration space and bar0 register
  33  *  values
  34  ******************************************/
  35 #include "xge_info.h"
  36
  37 int
  38 main( int argc, char *argv[] )
  39 {
  40     if(argc >= 4) {
  41         if(!((strcmp(argv[2], "-r")          == 0) ||
  42              (strcmp(argv[2], "-w")          == 0) ||
  43              (strcmp(argv[2], "chgbufmode")  == 0)))
  44               { goto use; }
  45       }
  46     else {
  47
  48         if(argc != 3) { goto out; }
  49
  50         else
  51           {
  52             if(!((strcmp(argv[2], "stats")         == 0) ||
  53                  (strcmp(argv[2], "pciconf")       == 0) ||
  54                  (strcmp(argv[2], "devconf")       == 0) ||
  55                  (strcmp(argv[2], "reginfo")       == 0) ||
  56                  (strcmp(argv[2], "driverversion") == 0) ||
  57                  (strcmp(argv[2], "swstats")       == 0) ||
  58                  (strcmp(argv[2], "getbufmode")    == 0) ||
  59                  (strcmp(argv[2], "intr")          == 0)))
  60                   { goto out; }
  61           }
  62       }
  63
  64     if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  65       {
  66         printf("Creating socket failed\n");
  67         return EXIT_FAILURE;
  68       }
  69
  70     ifreqp.ifr_addr.sa_family = AF_INET;
  71     strcpy(ifreqp.ifr_name, argv[1]);
  72
  73     if     (strcmp(argv[2], "pciconf")       == 0) return getPciConf();
  74     else if(strcmp(argv[2], "devconf")       == 0) return getDevConf();
  75     else if(strcmp(argv[2], "stats")         == 0) return getStats();
  76     else if(strcmp(argv[2], "reginfo")       == 0) return getRegInfo();
  77     else if(strcmp(argv[2], "intr")          == 0) return getIntrStats();
  78     else if(strcmp(argv[2], "swstats")       == 0) return getTcodeStats();
  79     else if(strcmp(argv[2], "driverversion") == 0) return getDriverVer();
  80     else if(strcmp(argv[2], "-r")            == 0) return getReadReg(argv[2],
  81     argv[3]);
  82     else if(strcmp(argv[2], "-w")            == 0) return getWriteReg(argv[2],
  83     argv[3],argv[5]);
  84     else if(strcmp(argv[2], "chgbufmode") == 0) return changeBufMode(argv[3]);
  85     else if(strcmp(argv[2], "getbufmode") == 0) return getBufMode();
  86     else return EXIT_FAILURE;
  87
  88 use:
  89     printf("Usage:");
  90     printf("%s <INTERFACE> [-r] [-w] [chgbufmode]\n", argv[0]);
  91     printf("\t -r <offset>               : Read register  \n");
  92     printf("\t -w <offset> -v <value>    : Write register \n");
  93     printf("\t chgbufmode <Buffer mode>  : Changes buffer mode \n");
  94     return EXIT_FAILURE;
  95
  96 out:
  97     printf("Usage:");
  98     printf("%s <INTERFACE> <[stats] [reginfo] [pciconf] [devconf] ", argv[0]);
  99     printf("[intr] [swstats] [driverversion] ");
 100     printf("[getbufmode] [chgbufmode] [-r] [-w] >\n");
 101     printf("\tINTERFACE               : Interface (xge0, xge1, xge2, ..)\n");
 102     printf("\tstats                   : Prints statistics               \n");
 103     printf("\treginfo                 : Prints register values          \n");
 104     printf("\tpciconf                 : Prints PCI configuration space  \n");
 105     printf("\tdevconf                 : Prints device configuration     \n");
 106     printf("\tintr                    : Prints interrupt statistics     \n");
 107     printf("\tswstats                 : Prints sw statistics            \n");
 108     printf("\tdriverversion           : Prints driver version           \n");
 109     printf("\tgetbufmode              : Prints Buffer Mode              \n");
 110     printf("\tchgbufmode              : Changes buffer mode             \n");
 111     printf("\t -r <offset>            : Read register                   \n");
 112     printf("\t -w <offset> -v <value> : Write register                  \n");
 113     return EXIT_FAILURE;
 114 }
 115
 116 int
 117 getStats()
 118 {
 119     void *hw_stats;
 120     void *pci_cfg;
 121     unsigned short device_id;
 122     int index    = 0;
 123     bufferSize = GET_OFFSET_STATS(XGE_COUNT_STATS - 1) + 8;
 124
 125     hw_stats   = (void *) malloc(bufferSize);
 126     if(!hw_stats)
 127     {
 128         printf("Allocating memory for hw_stats failed\n");
 129         return EXIT_FAILURE;
 130     }
 131     pAccess         = (char *)hw_stats;
 132     *pAccess        = XGE_QUERY_STATS;
 133     ifreqp.ifr_data = (caddr_t) hw_stats;
 134
 135     if(ioctl(sockfd, SIOCGPRIVATE_0, &ifreqp) < 0)
 136     {
 137         printf("Getting hardware statistics failed\n");
 138         free(hw_stats);
 139         return EXIT_FAILURE;
 140     }
 141     bufferSize = GET_OFFSET_PCICONF(XGE_COUNT_PCICONF -1) + 8;
 142
 143     pci_cfg = (void *) malloc(bufferSize);
 144     if(!pci_cfg)
 145     {
 146         printf("Allocating memory for pci_cfg  failed\n");
 147         return EXIT_FAILURE;
 148     }
 149
 150     pAccess         = (char *)pci_cfg;
 151     *pAccess        = XGE_QUERY_PCICONF;
 152     ifreqp.ifr_data = (caddr_t)pci_cfg;
 153
 154     if(ioctl(sockfd, SIOCGPRIVATE_0, &ifreqp) < 0)
 155     {
 156         printf("Getting pci configuration space failed\n");
 157         free(pci_cfg);
 158         return EXIT_FAILURE;
 159     }
 160     device_id = *( ( u16 * )( ( unsigned char * )pci_cfg +
 161                 GET_OFFSET_PCICONF(index) ) );
 162
 163     logStats( hw_stats,device_id );
 164     free(hw_stats);
 165     free(pci_cfg);
 166     return EXIT_SUCCESS;
 167 }
 168
 169 int
 170 getPciConf()
 171 {
 172     void *pci_cfg;
 173
 174     indexer = 0;
 175     bufferSize = GET_OFFSET_PCICONF(XGE_COUNT_PCICONF -1) + 8;
 176
 177     pci_cfg = (void *) malloc(bufferSize);
 178     if(!pci_cfg)
 179     {
 180         printf("Allocating memory for pci_cfg  failed\n");
 181         return EXIT_FAILURE;
 182     }
 183
 184     pAccess         = (char *)pci_cfg;
 185     *pAccess        = XGE_QUERY_PCICONF;
 186     ifreqp.ifr_data = (caddr_t)pci_cfg;
 187
 188     if(ioctl(sockfd, SIOCGPRIVATE_0, &ifreqp) < 0)
 189     {
 190         printf("Getting pci configuration space failed\n");
 191         free(pci_cfg);
 192         return EXIT_FAILURE;
 193     }
 194
 195     logPciConf( pci_cfg );
 196     free(pci_cfg);
 197     return EXIT_SUCCESS;
 198 }
 199
 200 int
 201 getDevConf()
 202 {
 203     void *device_cfg;
 204
 205     indexer    = 0;
 206     bufferSize = XGE_COUNT_DEVCONF * sizeof(int);
 207
 208     device_cfg = (void *) malloc(bufferSize);
 209     if(!device_cfg)
 210     {
 211         printf("Allocating memory for device_cfg  failed\n");
 212         return EXIT_FAILURE;
 213     }
 214     pAccess         = (char *)device_cfg;
 215     *pAccess        = XGE_QUERY_DEVCONF;
 216     ifreqp.ifr_data = (caddr_t)device_cfg;
 217
 218     if(ioctl(sockfd, SIOCGPRIVATE_0, &ifreqp) < 0)
 219     {
 220         printf("Getting Device Configuration failed\n");
 221         free(device_cfg);
 222         return EXIT_FAILURE;
 223     }
 224
 225     logDevConf( device_cfg );
 226     free(device_cfg);
 227     return EXIT_SUCCESS;
 228 }
 229
 230 int
 231 getBufMode()
 232 {
 233     void *buf_mode = 0;
 234
 235     buf_mode = (void *) malloc(sizeof(int));
 236     if(!buf_mode)
 237     {
 238         printf("Allocating memory for Buffer mode parameter  failed\n");
 239         return EXIT_FAILURE;
 240     }
 241
 242     pAccess         = (char *)buf_mode;
 243     *pAccess        = XGE_QUERY_BUFFER_MODE;
 244     ifreqp.ifr_data = (void *)buf_mode;
 245
 246     if(ioctl(sockfd, SIOCGPRIVATE_0, &ifreqp) < 0)
 247     {
 248         printf("Getting Buffer Mode failed\n");
 249         free(buf_mode);
 250         return EXIT_FAILURE;
 251     }
 252     printf("Buffer Mode is %d\n", *ifreqp.ifr_data);
 253     free(buf_mode);
 254     return EXIT_SUCCESS;
 255 }
 256
 257
 258 int
 259 changeBufMode(char *bufmode)
 260 {
 261
 262     char *print_msg;
 263     pAccess = (char *)malloc(sizeof(char));
 264
 265     if(*bufmode == '1'){
 266          *pAccess         =  XGE_SET_BUFFER_MODE_1;
 267     }else if (*bufmode == '2'){
 268          *pAccess         =  XGE_SET_BUFFER_MODE_2;
 269     }else if (*bufmode == '3'){
 270          *pAccess         =  XGE_SET_BUFFER_MODE_3;
 271     }else if (*bufmode == '5'){
 272          *pAccess         =  XGE_SET_BUFFER_MODE_5;
 273     }else{
 274          printf("Invalid Buffer mode\n");
 275          return EXIT_FAILURE;
 276      }
 277
 278     ifreqp.ifr_data = (char *)pAccess;
 279     if( ioctl( sockfd, SIOCGPRIVATE_0, &ifreqp ) < 0 )
 280     {
 281         printf( "Changing Buffer Mode Failed\n" );
 282         return EXIT_FAILURE;
 283     }
 284     print_msg = (char *)ifreqp.ifr_data;
 285     if(*print_msg == 'Y')
 286         printf("Requested buffer mode was already enabled\n");
 287     else if(*print_msg == 'N')
 288         printf("Requested buffer mode is not implemented OR\nDynamic buffer changing is not supported in this driver\n");
 289     else if(*print_msg == 'C')
 290         printf("Buffer mode changed to %c\n", *bufmode);
 291
 292     return EXIT_SUCCESS;
 293 }
 294
 295
 296 int
 297 getRegInfo()
 298 {
 299     void *regBuffer;
 300
 301     indexer     = 0;
 302     bufferSize = regInfo[XGE_COUNT_REGS - 1].offset + 8;
 303
 304     regBuffer = ( void * ) malloc ( bufferSize );
 305     if( !regBuffer )
 306     {
 307         printf( "Allocating memory for register dump failed\n" );
 308         return EXIT_FAILURE;
 309     }
 310
 311     ifreqp.ifr_data = ( caddr_t )regBuffer;
 312     if( ioctl( sockfd, SIOCGPRIVATE_1, &ifreqp ) < 0 )
 313     {
 314         printf( "Getting register dump failed\n" );
 315         free( regBuffer );
 316         return EXIT_FAILURE;
 317     }
 318
 319     logRegInfo( regBuffer );
 320     free( regBuffer );
 321     return EXIT_SUCCESS;
 322 }
 323
 324 int
 325 getReadReg(char *opt,char *offst)
 326 {
 327     bar0reg_t *reg;
 328
 329     reg = ( bar0reg_t * ) malloc (sizeof(bar0reg_t));
 330     if( !reg )
 331     {
 332         printf( "Allocating memory for reading register  failed\n" );
 333         return EXIT_FAILURE;
 334     }
 335     strcpy(reg->option, opt);
 336     sscanf(offst,"%x",&reg->offset);
 337     ifreqp.ifr_data = ( caddr_t )reg;
 338     if( ioctl( sockfd, SIOCGPRIVATE_1, &ifreqp ) < 0 )
 339     {
 340         printf( "Reading register failed\n" );
 341         free(reg);
 342         return EXIT_FAILURE;
 343     }
 344     logReadReg ( reg->offset,reg->value );
 345     free(reg);
 346     return EXIT_SUCCESS;
 347 }
 348
 349
 350 int
 351 getWriteReg(char *opt,char *offst,char *val)
 352 {
 353     bar0reg_t *reg;
 354
 355     reg = ( bar0reg_t * ) malloc (sizeof(bar0reg_t));
 356     if( !reg )
 357     {
 358         printf( "Allocating memory for writing  register  failed\n" );
 359         return EXIT_FAILURE;
 360     }
 361     strcpy(reg->option, opt);
 362     sscanf(offst,"%x",&reg->offset);
 363     sscanf(val,"%llx",&reg->value);
 364     ifreqp.ifr_data = ( caddr_t )reg;
 365     if( ioctl( sockfd, SIOCGPRIVATE_1, &ifreqp ) < 0 )
 366     {
 367         printf( "Writing register failed\n" );
 368         free(reg);
 369         return EXIT_FAILURE;
 370     }
 371     free(reg);
 372     return EXIT_SUCCESS;
 373 }
 374
 375
 376 int
 377 getIntrStats()
 378 {
 379     void *intr_stat;
 380
 381     bufferSize = XGE_COUNT_INTRSTAT * sizeof(u32);
 382
 383     intr_stat = (void *) malloc(bufferSize);
 384     if(!intr_stat)
 385     {
 386         printf("Allocating memory for intr_stat failed\n");
 387         return EXIT_FAILURE;
 388     }
 389     pAccess = (char *)intr_stat;
 390     *pAccess = XGE_QUERY_INTRSTATS ;
 391     ifreqp.ifr_data = (caddr_t)intr_stat;
 392
 393     if(ioctl(sockfd, SIOCGPRIVATE_0, &ifreqp) < 0)
 394     {
 395         printf("Getting interrupt statistics failed\n");
 396         free(intr_stat);
 397         return EXIT_FAILURE;
 398     }
 399     intr_stat = (char *)ifreqp.ifr_data;
 400
 401     logIntrStats( intr_stat );
 402     free(intr_stat);
 403     return EXIT_SUCCESS;
 404 }
 405
 406 int
 407 getTcodeStats()
 408 {
 409     void *tcode_stat;
 410
 411     bufferSize = XGE_COUNT_TCODESTAT * sizeof(u32);
 412
 413     tcode_stat = (void *) malloc(bufferSize);
 414     if(!tcode_stat)
 415     {
 416         printf("Allocating memory for tcode_stat failed\n");
 417         return EXIT_FAILURE;
 418     }
 419     pAccess = (char *)tcode_stat;
 420     *pAccess = XGE_QUERY_TCODE ;
 421     ifreqp.ifr_data = (caddr_t)tcode_stat;
 422     if(ioctl(sockfd, SIOCGPRIVATE_0, &ifreqp) < 0)
 423     {
 424         printf("Getting tcode statistics failed\n");
 425         free(tcode_stat);
 426         return EXIT_FAILURE;
 427     }
 428     tcode_stat = (char *)ifreqp.ifr_data;
 429
 430     logTcodeStats( tcode_stat );
 431     free(tcode_stat);
 432     return EXIT_SUCCESS;
 433 }
 434
 435 int
 436 getDriverVer()
 437 {
 438     char  *version;
 439     bufferSize = 20;
 440     version = ( char * ) malloc ( bufferSize );
 441     if( !version )
 442     {
 443         printf( "Allocating memory for getting driver version failed\n" );
 444         return EXIT_FAILURE;
 445     }
 446      pAccess         = version;
 447     *pAccess         = XGE_READ_VERSION;
 448
 449     ifreqp.ifr_data = ( caddr_t )version;
 450     if( ioctl( sockfd, SIOCGPRIVATE_0, &ifreqp ) < 0 )
 451     {
 452         printf( "Getting driver version failed\n" );
 453         free( version );
 454         return EXIT_FAILURE;
 455     }
 456     logDriverInfo(version);
 457     free( version );
 458     return EXIT_SUCCESS;
 459
 460 }
 461