lib/librte_eal/linuxapp/kni/ethtool/igb/igb_sysfs.c

   1 /*******************************************************************************
   2
   3   Intel(R) Gigabit Ethernet Linux driver
   4   Copyright(c) 2007-2012 Intel Corporation.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   You should have received a copy of the GNU General Public License along with
  16   this program; if not, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  24   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  25
  26 *******************************************************************************/
  27
  28 #include "igb.h"
  29 #include "e1000_82575.h"
  30 #include "e1000_hw.h"
  31 #ifdef IGB_SYSFS
  32 #include <linux/module.h>
  33 #include <linux/types.h>
  34 #include <linux/sysfs.h>
  35 #include <linux/kobject.h>
  36 #include <linux/device.h>
  37 #include <linux/netdevice.h>
  38
  39 static struct net_device_stats *sysfs_get_stats(struct net_device *netdev)
  40 {
  41 #ifndef HAVE_NETDEV_STATS_IN_NETDEV
  42         struct igb_adapter *adapter;
  43 #endif
  44         if (netdev == NULL)
  45                 return NULL;
  46
  47 #ifdef HAVE_NETDEV_STATS_IN_NETDEV
  48         /* only return the current stats */
  49         return &netdev->stats;
  50 #else
  51         adapter = netdev_priv(netdev);
  52
  53         /* only return the current stats */
  54         return &adapter->net_stats;
  55 #endif /* HAVE_NETDEV_STATS_IN_NETDEV */
  56 }
  57
  58 struct net_device *igb_get_netdev(struct kobject *kobj)
  59 {
  60         struct net_device *netdev;
  61         struct kobject *parent = kobj->parent;
  62         struct device *device_info_kobj;
  63
  64         if (kobj == NULL)
  65                 return NULL;
  66
  67         device_info_kobj = container_of(parent, struct device, kobj);
  68         if (device_info_kobj == NULL)
  69                 return NULL;
  70
  71         netdev = container_of(device_info_kobj, struct net_device, dev);
  72         return netdev;
  73 }
  74 struct igb_adapter *igb_get_adapter(struct kobject *kobj)
  75 {
  76         struct igb_adapter *adapter;
  77         struct net_device *netdev = igb_get_netdev(kobj);
  78         if (netdev == NULL)
  79                 return NULL;
  80         adapter = netdev_priv(netdev);
  81         return adapter;
  82 }
  83
  84 bool igb_thermal_present(struct kobject *kobj)
  85 {
  86         s32 status;
  87         struct igb_adapter *adapter = igb_get_adapter(kobj);
  88
  89         if (adapter == NULL)
  90                 return false;
  91
  92         /*
  93          * Only set I2C bit-bang mode if an external thermal sensor is
  94          * supported on this device.
  95          */
  96         if (adapter->ets) {
  97                 status = e1000_set_i2c_bb(&(adapter->hw));
  98                 if (status != E1000_SUCCESS)
  99                         return false;
 100         }
 101
 102         status = e1000_init_thermal_sensor_thresh(&(adapter->hw));
 103         if (status != E1000_SUCCESS)
 104                 return false;
 105
 106         return true;
 107 }
 108
 109 /*
 110  * Convert the directory to the sensor offset.
 111  *
 112  * Note: We know the name will be in the form of 'sensor_n' where 'n' is 0
 113  * - 'IGB_MAX_SENSORS'.  E1000_MAX_SENSORS < 10.
 114  */
 115 static int igb_name_to_idx(const char *c) {
 116
 117         /* find first digit */
 118         while (*c < '0' || *c > '9') {
 119                 if (*c == '\n')
 120                         return -1;
 121                 c++;
 122         }
 123
 124         return ((int)(*c - '0'));
 125 }
 126
 127 /*
 128  * We are a statistics entry; we do not take in data-this should be the
 129  * same for all attributes
 130  */
 131 static ssize_t igb_store(struct kobject *kobj,
 132                          struct kobj_attribute *attr,
 133                          const char *buf, size_t count)
 134 {
 135         return -1;
 136 }
 137
 138 static ssize_t igb_fwbanner(struct kobject *kobj,
 139                             struct kobj_attribute *attr, char *buf)
 140 {
 141         struct igb_adapter *adapter = igb_get_adapter(kobj);
 142         u16 nvm_ver;
 143
 144         if (adapter == NULL)
 145                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 146         nvm_ver = adapter->fw_version;
 147
 148         return snprintf(buf, PAGE_SIZE, "0x%08x\n", nvm_ver);
 149 }
 150
 151 static ssize_t igb_numeports(struct kobject *kobj,
 152                              struct kobj_attribute *attr, char *buf)
 153 {
 154         struct e1000_hw *hw;
 155         int ports = 0;
 156         struct igb_adapter *adapter = igb_get_adapter(kobj);
 157         if (adapter == NULL)
 158                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 159
 160         hw = &adapter->hw;
 161         if (hw == NULL)
 162                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 163
 164         /* CMW taking the original out so and assigning ports generally
 165          * by mac type for now.  Want to have the daemon handle this some
 166          * other way due to the variability of the 1GB parts.
 167          */
 168         switch (hw->mac.type) {
 169                 case e1000_82575:
 170                         ports = 2;
 171                         break;
 172                 case e1000_82576:
 173                         ports = 2;
 174                         break;
 175                 case e1000_82580:
 176                 case e1000_i350:
 177                         ports = 4;
 178                         break;
 179                 default:
 180                         break;
 181         }
 182
 183         return snprintf(buf, PAGE_SIZE, "%d\n", ports);
 184 }
 185
 186 static ssize_t igb_porttype(struct kobject *kobj,
 187                             struct kobj_attribute *attr, char *buf)
 188 {
 189         struct igb_adapter *adapter = igb_get_adapter(kobj);
 190         if (adapter == NULL)
 191                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 192
 193         return snprintf(buf, PAGE_SIZE, "%d\n",
 194                         test_bit(__IGB_DOWN, &adapter->state));
 195 }
 196
 197 static ssize_t igb_portspeed(struct kobject *kobj,
 198                              struct kobj_attribute *attr, char *buf)
 199 {
 200         struct igb_adapter *adapter = igb_get_adapter(kobj);
 201         int speed = 0;
 202
 203         if (adapter == NULL)
 204                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 205
 206         switch (adapter->link_speed) {
 207         case E1000_STATUS_SPEED_10:
 208                 speed = 10;
 209                 break;;
 210         case E1000_STATUS_SPEED_100:
 211                 speed = 100;
 212                 break;
 213         case E1000_STATUS_SPEED_1000:
 214                 speed = 1000;
 215                 break;
 216         }
 217         return snprintf(buf, PAGE_SIZE, "%d\n", speed);
 218 }
 219
 220 static ssize_t igb_wqlflag(struct kobject *kobj,
 221                            struct kobj_attribute *attr, char *buf)
 222 {
 223         struct igb_adapter *adapter = igb_get_adapter(kobj);
 224         if (adapter == NULL)
 225                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 226
 227         return snprintf(buf, PAGE_SIZE, "%d\n", adapter->wol);
 228 }
 229
 230 static ssize_t igb_xflowctl(struct kobject *kobj,
 231                             struct kobj_attribute *attr, char *buf)
 232 {
 233         struct e1000_hw *hw;
 234         struct igb_adapter *adapter = igb_get_adapter(kobj);
 235         if (adapter == NULL)
 236                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 237
 238         hw = &adapter->hw;
 239         if (hw == NULL)
 240                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 241
 242         return snprintf(buf, PAGE_SIZE, "%d\n", hw->fc.current_mode);
 243 }
 244
 245 static ssize_t igb_rxdrops(struct kobject *kobj,
 246                            struct kobj_attribute *attr, char *buf)
 247 {
 248         struct net_device_stats *net_stats;
 249         struct net_device *netdev = igb_get_netdev(kobj);
 250         if (netdev == NULL)
 251                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 252
 253         net_stats  = sysfs_get_stats(netdev);
 254         if (net_stats == NULL)
 255                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 256
 257         return snprintf(buf, PAGE_SIZE, "%lu\n",
 258                         net_stats->rx_dropped);
 259 }
 260
 261 static ssize_t igb_rxerrors(struct kobject *kobj,
 262                             struct kobj_attribute *attr, char *buf)
 263 {
 264         struct net_device_stats *net_stats;
 265         struct net_device *netdev = igb_get_netdev(kobj);
 266         if (netdev == NULL)
 267                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 268
 269         net_stats  = sysfs_get_stats(netdev);
 270         if (net_stats == NULL)
 271                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 272         return snprintf(buf, PAGE_SIZE, "%lu\n", net_stats->rx_errors);
 273 }
 274
 275 static ssize_t igb_rxupacks(struct kobject *kobj,
 276                             struct kobj_attribute *attr, char *buf)
 277 {
 278         struct e1000_hw *hw;
 279         struct igb_adapter *adapter = igb_get_adapter(kobj);
 280         if (adapter == NULL)
 281                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 282
 283         hw = &adapter->hw;
 284         if (hw == NULL)
 285                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 286
 287         return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_TPR));
 288 }
 289
 290 static ssize_t igb_rxmpacks(struct kobject *kobj,
 291                             struct kobj_attribute *attr, char *buf)
 292 {
 293         struct e1000_hw *hw;
 294         struct igb_adapter *adapter = igb_get_adapter(kobj);
 295         if (adapter == NULL)
 296                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 297
 298         hw = &adapter->hw;
 299         if (hw == NULL)
 300                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 301
 302         return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_MPRC));
 303 }
 304
 305 static ssize_t igb_rxbpacks(struct kobject *kobj,
 306                             struct kobj_attribute *attr, char *buf)
 307 {
 308         struct e1000_hw *hw;
 309         struct igb_adapter *adapter = igb_get_adapter(kobj);
 310         if (adapter == NULL)
 311                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 312
 313         hw = &adapter->hw;
 314         if (hw == NULL)
 315                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 316
 317         return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_BPRC));
 318 }
 319
 320 static ssize_t igb_txupacks(struct kobject *kobj,
 321                             struct kobj_attribute *attr, char *buf)
 322 {
 323         struct e1000_hw *hw;
 324         struct igb_adapter *adapter = igb_get_adapter(kobj);
 325         if (adapter == NULL)
 326                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 327
 328         hw = &adapter->hw;
 329         if (hw == NULL)
 330                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 331
 332         return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_TPT));
 333 }
 334
 335 static ssize_t igb_txmpacks(struct kobject *kobj,
 336                             struct kobj_attribute *attr, char *buf)
 337 {
 338         struct e1000_hw *hw;
 339         struct igb_adapter *adapter = igb_get_adapter(kobj);
 340         if (adapter == NULL)
 341                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 342
 343         hw = &adapter->hw;
 344         if (hw == NULL)
 345                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 346
 347         return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_MPTC));
 348 }
 349
 350 static ssize_t igb_txbpacks(struct kobject *kobj,
 351                             struct kobj_attribute *attr, char *buf)
 352 {
 353         struct e1000_hw *hw;
 354         struct igb_adapter *adapter = igb_get_adapter(kobj);
 355         if (adapter == NULL)
 356                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 357
 358         hw = &adapter->hw;
 359         if (hw == NULL)
 360                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 361
 362         return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_BPTC));
 363
 364 }
 365
 366 static ssize_t igb_txerrors(struct kobject *kobj,
 367                             struct kobj_attribute *attr, char *buf)
 368 {
 369         struct net_device_stats *net_stats;
 370         struct net_device *netdev = igb_get_netdev(kobj);
 371         if (netdev == NULL)
 372                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 373
 374         net_stats  = sysfs_get_stats(netdev);
 375         if (net_stats == NULL)
 376                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 377
 378         return snprintf(buf, PAGE_SIZE, "%lu\n",
 379                         net_stats->tx_errors);
 380 }
 381
 382 static ssize_t igb_txdrops(struct kobject *kobj,
 383                            struct kobj_attribute *attr, char *buf)
 384 {
 385         struct net_device_stats *net_stats;
 386         struct net_device *netdev = igb_get_netdev(kobj);
 387         if (netdev == NULL)
 388                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 389
 390         net_stats  = sysfs_get_stats(netdev);
 391         if (net_stats == NULL)
 392                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 393         return snprintf(buf, PAGE_SIZE, "%lu\n",
 394                         net_stats->tx_dropped);
 395 }
 396
 397 static ssize_t igb_rxframes(struct kobject *kobj,
 398                             struct kobj_attribute *attr, char *buf)
 399 {
 400         struct net_device_stats *net_stats;
 401         struct net_device *netdev = igb_get_netdev(kobj);
 402         if (netdev == NULL)
 403                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 404
 405         net_stats  = sysfs_get_stats(netdev);
 406         if (net_stats == NULL)
 407                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 408
 409         return snprintf(buf, PAGE_SIZE, "%lu\n",
 410                         net_stats->rx_packets);
 411 }
 412
 413 static ssize_t igb_rxbytes(struct kobject *kobj,
 414                            struct kobj_attribute *attr, char *buf)
 415 {
 416         struct net_device_stats *net_stats;
 417         struct net_device *netdev = igb_get_netdev(kobj);
 418         if (netdev == NULL)
 419                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 420
 421         net_stats  = sysfs_get_stats(netdev);
 422         if (net_stats == NULL)
 423                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 424
 425         return snprintf(buf, PAGE_SIZE, "%lu\n",
 426                         net_stats->rx_bytes);
 427 }
 428
 429 static ssize_t igb_txframes(struct kobject *kobj,
 430                             struct kobj_attribute *attr, char *buf)
 431 {
 432         struct net_device_stats *net_stats;
 433         struct net_device *netdev = igb_get_netdev(kobj);
 434         if (netdev == NULL)
 435                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 436
 437         net_stats  = sysfs_get_stats(netdev);
 438         if (net_stats == NULL)
 439                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 440
 441         return snprintf(buf, PAGE_SIZE, "%lu\n",
 442                         net_stats->tx_packets);
 443 }
 444
 445 static ssize_t igb_txbytes(struct kobject *kobj,
 446                            struct kobj_attribute *attr, char *buf)
 447 {
 448         struct net_device_stats *net_stats;
 449         struct net_device *netdev = igb_get_netdev(kobj);
 450         if (netdev == NULL)
 451                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 452
 453         net_stats  = sysfs_get_stats(netdev);
 454         if (net_stats == NULL)
 455                 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
 456
 457         return snprintf(buf, PAGE_SIZE, "%lu\n",
 458                         net_stats->tx_bytes);
 459 }
 460
 461 static ssize_t igb_linkstat(struct kobject *kobj,
 462                             struct kobj_attribute *attr, char *buf)
 463 {
 464         bool link_up = false;
 465         int bitmask = 0;
 466         struct e1000_hw *hw;
 467         struct igb_adapter *adapter = igb_get_adapter(kobj);
 468         if (adapter == NULL)
 469                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 470
 471         hw = &adapter->hw;
 472         if (hw == NULL)
 473                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 474
 475         if (test_bit(__IGB_DOWN, &adapter->state))
 476                 bitmask |= 1;
 477
 478         if (hw->mac.ops.check_for_link) {
 479                 hw->mac.ops.check_for_link(hw);
 480         }
 481         else {
 482                 /* always assume link is up, if no check link function */
 483                 link_up = true;
 484         }
 485         if (link_up)
 486                 bitmask |= 2;
 487         return snprintf(buf, PAGE_SIZE, "0x%X\n", bitmask);
 488 }
 489
 490 static ssize_t igb_funcid(struct kobject *kobj,
 491                           struct kobj_attribute *attr, char *buf)
 492 {
 493         struct net_device *netdev = igb_get_netdev(kobj);
 494         if (netdev == NULL)
 495                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 496
 497         return snprintf(buf, PAGE_SIZE, "0x%lX\n", netdev->base_addr);
 498 }
 499
 500 static ssize_t igb_funcvers(struct kobject *kobj,
 501                             struct kobj_attribute *attr, char *buf)
 502 {
 503         return snprintf(buf, PAGE_SIZE, "%s\n", igb_driver_version);
 504 }
 505
 506 static ssize_t igb_macburn(struct kobject *kobj,
 507                            struct kobj_attribute *attr, char *buf)
 508 {
 509         struct e1000_hw *hw;
 510         struct igb_adapter *adapter = igb_get_adapter(kobj);
 511         if (adapter == NULL)
 512                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 513
 514         hw = &adapter->hw;
 515         if (hw == NULL)
 516                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 517
 518         return snprintf(buf, PAGE_SIZE, "0x%X%X%X%X%X%X\n",
 519                        (unsigned int)hw->mac.perm_addr[0],
 520                        (unsigned int)hw->mac.perm_addr[1],
 521                        (unsigned int)hw->mac.perm_addr[2],
 522                        (unsigned int)hw->mac.perm_addr[3],
 523                        (unsigned int)hw->mac.perm_addr[4],
 524                        (unsigned int)hw->mac.perm_addr[5]);
 525 }
 526
 527 static ssize_t igb_macadmn(struct kobject *kobj,
 528                            struct kobj_attribute *attr, char *buf)
 529 {
 530         struct igb_adapter *adapter = igb_get_adapter(kobj);
 531         struct e1000_hw *hw;
 532
 533         if (adapter == NULL)
 534                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 535
 536         hw = &adapter->hw;
 537         if (hw == NULL)
 538                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 539
 540         return snprintf(buf, PAGE_SIZE, "0x%X%X%X%X%X%X\n",
 541                        (unsigned int)hw->mac.addr[0],
 542                        (unsigned int)hw->mac.addr[1],
 543                        (unsigned int)hw->mac.addr[2],
 544                        (unsigned int)hw->mac.addr[3],
 545                        (unsigned int)hw->mac.addr[4],
 546                        (unsigned int)hw->mac.addr[5]);
 547 }
 548
 549 static ssize_t igb_maclla1(struct kobject *kobj,
 550                            struct kobj_attribute *attr, char *buf)
 551 {
 552         struct e1000_hw *hw;
 553         u16 eeprom_buff[6];
 554         int first_word = 0x37;
 555         int word_count = 6;
 556         int rc;
 557
 558         struct igb_adapter *adapter = igb_get_adapter(kobj);
 559         if (adapter == NULL)
 560                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 561
 562         hw = &adapter->hw;
 563         if (hw == NULL)
 564                 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
 565
 566         return 0;
 567
 568         rc = e1000_read_nvm(hw, first_word, word_count,
 569                                            eeprom_buff);
 570         if (rc != E1000_SUCCESS)
 571                 return 0;
 572
 573         switch (hw->bus.func) {
 574         case 0:
 575                 return snprintf(buf, PAGE_SIZE, "0x%04X%04X%04X\n",
 576                                 eeprom_buff[0], eeprom_buff[1], eeprom_buff[2]);
 577         case 1:
 578                 return snprintf(buf, PAGE_SIZE, "0x%04X%04X%04X\n",
 579                                 eeprom_buff[3], eeprom_buff[4], eeprom_buff[5]);
 580         }
 581         return snprintf(buf, PAGE_SIZE, "unexpected port %d\n", hw->bus.func);
 582 }
 583
 584 static ssize_t igb_mtusize(struct kobject *kobj,
 585                               struct kobj_attribute *attr, char *buf)
 586 {
 587         struct igb_adapter *adapter = igb_get_adapter(kobj);
 588         struct net_device *netdev = igb_get_netdev(kobj);
 589         if (netdev == NULL)
 590                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 591
 592         if (adapter == NULL)
 593                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 594
 595         return snprintf(buf, PAGE_SIZE, "%d\n", netdev->mtu);
 596 }
 597
 598 static ssize_t igb_featflag(struct kobject *kobj,
 599                             struct kobj_attribute *attr, char *buf)
 600 {
 601 #ifdef HAVE_NDO_SET_FEATURES
 602         int bitmask = 0;
 603 #endif
 604         struct net_device *netdev = igb_get_netdev(kobj);
 605         struct igb_adapter *adapter = igb_get_adapter(kobj);
 606
 607         if (adapter == NULL)
 608                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 609         if (netdev == NULL)
 610                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 611
 612 #ifndef HAVE_NDO_SET_FEATURES
 613         /* igb_get_rx_csum(netdev) doesn't compile so hard code */
 614         return snprintf(buf, PAGE_SIZE, "%d\n",
 615                         test_bit(IGB_RING_FLAG_RX_CSUM,
 616                                  &adapter->rx_ring[0]->flags));
 617 #else
 618         if (netdev->features & NETIF_F_RXCSUM)
 619                 bitmask |= 1;
 620         return snprintf(buf, PAGE_SIZE, "%d\n", bitmask);
 621 #endif
 622 }
 623
 624 static ssize_t igb_lsominct(struct kobject *kobj,
 625                             struct kobj_attribute *attr, char *buf)
 626 {
 627         return snprintf(buf, PAGE_SIZE, "%d\n", 1);
 628 }
 629
 630 static ssize_t igb_prommode(struct kobject *kobj,
 631                             struct kobj_attribute *attr, char *buf)
 632 {
 633         struct net_device *netdev = igb_get_netdev(kobj);
 634         if (netdev == NULL)
 635                 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
 636
 637         return snprintf(buf, PAGE_SIZE, "%d\n",
 638                         netdev->flags & IFF_PROMISC);
 639 }
 640
 641 static ssize_t igb_txdscqsz(struct kobject *kobj,
 642                             struct kobj_attribute *attr, char *buf)
 643 {
 644         struct igb_adapter *adapter = igb_get_adapter(kobj);
 645         if (adapter == NULL)
 646                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 647
 648         return snprintf(buf, PAGE_SIZE, "%d\n", adapter->tx_ring[0]->count);
 649 }
 650
 651 static ssize_t igb_rxdscqsz(struct kobject *kobj,
 652                             struct kobj_attribute *attr, char *buf)
 653 {
 654         struct igb_adapter *adapter = igb_get_adapter(kobj);
 655         if (adapter == NULL)
 656                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 657
 658         return snprintf(buf, PAGE_SIZE, "%d\n", adapter->rx_ring[0]->count);
 659 }
 660
 661 static ssize_t igb_rxqavg(struct kobject *kobj,
 662                           struct kobj_attribute *attr, char *buf)
 663 {
 664         int index;
 665         int diff = 0;
 666         u16 ntc;
 667         u16 ntu;
 668         struct igb_adapter *adapter = igb_get_adapter(kobj);
 669         if (adapter == NULL)
 670                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 671
 672         for (index = 0; index < adapter->num_rx_queues; index++) {
 673                 ntc = adapter->rx_ring[index]->next_to_clean;
 674                 ntu = adapter->rx_ring[index]->next_to_use;
 675
 676                 if (ntc >= ntu)
 677                         diff += (ntc - ntu);
 678                 else
 679                         diff += (adapter->rx_ring[index]->count - ntu + ntc);
 680         }
 681         if (adapter->num_rx_queues <= 0)
 682                 return snprintf(buf, PAGE_SIZE,
 683                                 "can't calculate, number of queues %d\n",
 684                                 adapter->num_rx_queues);
 685         return snprintf(buf, PAGE_SIZE, "%d\n", diff/adapter->num_rx_queues);
 686 }
 687
 688 static ssize_t igb_txqavg(struct kobject *kobj,
 689                           struct kobj_attribute *attr, char *buf)
 690 {
 691         int index;
 692         int diff = 0;
 693         u16 ntc;
 694         u16 ntu;
 695         struct igb_adapter *adapter = igb_get_adapter(kobj);
 696         if (adapter == NULL)
 697                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 698
 699         for (index = 0; index < adapter->num_tx_queues; index++) {
 700                 ntc = adapter->tx_ring[index]->next_to_clean;
 701                 ntu = adapter->tx_ring[index]->next_to_use;
 702
 703                 if (ntc >= ntu)
 704                         diff += (ntc - ntu);
 705                 else
 706                         diff += (adapter->tx_ring[index]->count - ntu + ntc);
 707         }
 708         if (adapter->num_tx_queues <= 0)
 709                 return snprintf(buf, PAGE_SIZE,
 710                                 "can't calculate, number of queues %d\n",
 711                                 adapter->num_tx_queues);
 712         return snprintf(buf, PAGE_SIZE, "%d\n",
 713                         diff/adapter->num_tx_queues);
 714 }
 715
 716 static ssize_t igb_iovotype(struct kobject *kobj,
 717                             struct kobj_attribute *attr, char *buf)
 718 {
 719         return snprintf(buf, PAGE_SIZE, "2\n");
 720 }
 721
 722 static ssize_t igb_funcnbr(struct kobject *kobj,
 723                            struct kobj_attribute *attr, char *buf)
 724 {
 725         struct igb_adapter *adapter = igb_get_adapter(kobj);
 726         if (adapter == NULL)
 727                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 728
 729         return snprintf(buf, PAGE_SIZE, "%d\n", adapter->vfs_allocated_count);
 730 }
 731
 732 s32 igb_sysfs_get_thermal_data(struct kobject *kobj, char *buf)
 733 {
 734         s32 status;
 735         struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
 736
 737         if (adapter == NULL) {
 738                 snprintf(buf, PAGE_SIZE, "error: missing adapter\n");
 739                 return 0;
 740         }
 741
 742         if (&adapter->hw == NULL) {
 743                 snprintf(buf, PAGE_SIZE, "error: missing hw\n");
 744                 return 0;
 745         }
 746
 747         status = e1000_get_thermal_sensor_data_generic(&(adapter->hw));
 748         if (status != E1000_SUCCESS)
 749                 snprintf(buf, PAGE_SIZE, "error: status %d returned\n", status);
 750
 751         return status;
 752 }
 753
 754 static ssize_t igb_sysfs_location(struct kobject *kobj,
 755                                      struct kobj_attribute *attr,
 756                                      char *buf)
 757 {
 758         struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
 759         int idx;
 760
 761         if (adapter == NULL)
 762                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 763
 764         idx = igb_name_to_idx(kobj->name);
 765         if (idx == -1)
 766                 return snprintf(buf, PAGE_SIZE,
 767                         "error: invalid sensor name %s\n", kobj->name);
 768
 769         return snprintf(buf, PAGE_SIZE, "%d\n",
 770                         adapter->hw.mac.thermal_sensor_data.sensor[idx].location);
 771 }
 772
 773 static ssize_t igb_sysfs_temp(struct kobject *kobj,
 774                                  struct kobj_attribute *attr,
 775                                  char *buf)
 776 {
 777         struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
 778         int idx;
 779
 780         s32 status = igb_sysfs_get_thermal_data(kobj, buf);
 781
 782         if (status != E1000_SUCCESS)
 783                 return snprintf(buf, PAGE_SIZE, "error: status %d returned",
 784                                 status);
 785
 786         idx = igb_name_to_idx(kobj->name);
 787         if (idx == -1)
 788                 return snprintf(buf, PAGE_SIZE,
 789                         "error: invalid sensor name %s\n", kobj->name);
 790
 791         return snprintf(buf, PAGE_SIZE, "%d\n",
 792                         adapter->hw.mac.thermal_sensor_data.sensor[idx].temp);
 793 }
 794
 795 static ssize_t igb_sysfs_maxopthresh(struct kobject *kobj,
 796                                         struct kobj_attribute *attr,
 797                                         char *buf)
 798 {
 799         struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
 800         int idx;
 801         if (adapter == NULL)
 802                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 803
 804         idx = igb_name_to_idx(kobj->name);
 805         if (idx == -1)
 806                 return snprintf(buf, PAGE_SIZE,
 807                         "error: invalid sensor name %s\n", kobj->name);
 808
 809         return snprintf(buf, PAGE_SIZE, "%d\n",
 810                 adapter->hw.mac.thermal_sensor_data.sensor[idx].max_op_thresh);
 811 }
 812
 813 static ssize_t igb_sysfs_cautionthresh(struct kobject *kobj,
 814                                           struct kobj_attribute *attr,
 815                                           char *buf)
 816 {
 817         struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
 818         int idx;
 819
 820         if (adapter == NULL)
 821                 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
 822
 823         idx = igb_name_to_idx(kobj->name);
 824         if (idx == -1)
 825                 return snprintf(buf, PAGE_SIZE,
 826                         "error: invalid sensor name %s\n", kobj->name);
 827
 828         return snprintf(buf, PAGE_SIZE, "%d\n",
 829                 adapter->hw.mac.thermal_sensor_data.sensor[0].caution_thresh);
 830 }
 831
 832 /* Initialize the attributes */
 833 static struct kobj_attribute igb_sysfs_location_attr =
 834         __ATTR(location, 0444, igb_sysfs_location, igb_store);
 835 static struct kobj_attribute igb_sysfs_temp_attr =
 836         __ATTR(temp, 0444, igb_sysfs_temp, igb_store);
 837 static struct kobj_attribute igb_sysfs_cautionthresh_attr =
 838         __ATTR(cautionthresh, 0444, igb_sysfs_cautionthresh, igb_store);
 839 static struct kobj_attribute igb_sysfs_maxopthresh_attr =
 840         __ATTR(maxopthresh, 0444, igb_sysfs_maxopthresh, igb_store);
 841
 842 static struct kobj_attribute igb_sysfs_fwbanner_attr =
 843         __ATTR(fwbanner, 0444, igb_fwbanner, igb_store);
 844 static struct kobj_attribute igb_sysfs_numeports_attr =
 845         __ATTR(numeports, 0444, igb_numeports, igb_store);
 846 static struct kobj_attribute igb_sysfs_porttype_attr =
 847         __ATTR(porttype, 0444, igb_porttype, igb_store);
 848 static struct kobj_attribute igb_sysfs_portspeed_attr =
 849         __ATTR(portspeed, 0444, igb_portspeed, igb_store);
 850 static struct kobj_attribute igb_sysfs_wqlflag_attr =
 851         __ATTR(wqlflag, 0444, igb_wqlflag, igb_store);
 852 static struct kobj_attribute igb_sysfs_xflowctl_attr =
 853         __ATTR(xflowctl, 0444, igb_xflowctl, igb_store);
 854 static struct kobj_attribute igb_sysfs_rxdrops_attr =
 855         __ATTR(rxdrops, 0444, igb_rxdrops, igb_store);
 856 static struct kobj_attribute igb_sysfs_rxerrors_attr =
 857         __ATTR(rxerrors, 0444, igb_rxerrors, igb_store);
 858 static struct kobj_attribute igb_sysfs_rxupacks_attr =
 859         __ATTR(rxupacks, 0444, igb_rxupacks, igb_store);
 860 static struct kobj_attribute igb_sysfs_rxmpacks_attr =
 861         __ATTR(rxmpacks, 0444, igb_rxmpacks, igb_store);
 862 static struct kobj_attribute igb_sysfs_rxbpacks_attr =
 863         __ATTR(rxbpacks, 0444, igb_rxbpacks, igb_store);
 864 static struct kobj_attribute igb_sysfs_txupacks_attr =
 865         __ATTR(txupacks, 0444, igb_txupacks, igb_store);
 866 static struct kobj_attribute igb_sysfs_txmpacks_attr =
 867         __ATTR(txmpacks, 0444, igb_txmpacks, igb_store);
 868 static struct kobj_attribute igb_sysfs_txbpacks_attr =
 869         __ATTR(txbpacks, 0444, igb_txbpacks, igb_store);
 870 static struct kobj_attribute igb_sysfs_txerrors_attr =
 871         __ATTR(txerrors, 0444, igb_txerrors, igb_store);
 872 static struct kobj_attribute igb_sysfs_txdrops_attr =
 873         __ATTR(txdrops, 0444, igb_txdrops, igb_store);
 874 static struct kobj_attribute igb_sysfs_rxframes_attr =
 875         __ATTR(rxframes, 0444, igb_rxframes, igb_store);
 876 static struct kobj_attribute igb_sysfs_rxbytes_attr =
 877         __ATTR(rxbytes, 0444, igb_rxbytes, igb_store);
 878 static struct kobj_attribute igb_sysfs_txframes_attr =
 879         __ATTR(txframes, 0444, igb_txframes, igb_store);
 880 static struct kobj_attribute igb_sysfs_txbytes_attr =
 881         __ATTR(txbytes, 0444, igb_txbytes, igb_store);
 882 static struct kobj_attribute igb_sysfs_linkstat_attr =
 883         __ATTR(linkstat, 0444, igb_linkstat, igb_store);
 884 static struct kobj_attribute igb_sysfs_funcid_attr =
 885         __ATTR(funcid, 0444, igb_funcid, igb_store);
 886 static struct kobj_attribute igb_sysfs_funvers_attr =
 887         __ATTR(funcvers, 0444, igb_funcvers, igb_store);
 888 static struct kobj_attribute igb_sysfs_macburn_attr =
 889         __ATTR(macburn, 0444, igb_macburn, igb_store);
 890 static struct kobj_attribute igb_sysfs_macadmn_attr =
 891         __ATTR(macadmn, 0444, igb_macadmn, igb_store);
 892 static struct kobj_attribute igb_sysfs_maclla1_attr =
 893         __ATTR(maclla1, 0444, igb_maclla1, igb_store);
 894 static struct kobj_attribute igb_sysfs_mtusize_attr =
 895         __ATTR(mtusize, 0444, igb_mtusize, igb_store);
 896 static struct kobj_attribute igb_sysfs_featflag_attr =
 897         __ATTR(featflag, 0444, igb_featflag, igb_store);
 898 static struct kobj_attribute igb_sysfs_lsominct_attr =
 899         __ATTR(lsominct, 0444, igb_lsominct, igb_store);
 900 static struct kobj_attribute igb_sysfs_prommode_attr =
 901         __ATTR(prommode, 0444, igb_prommode, igb_store);
 902 static struct kobj_attribute igb_sysfs_txdscqsz_attr =
 903         __ATTR(txdscqsz, 0444, igb_txdscqsz, igb_store);
 904 static struct kobj_attribute igb_sysfs_rxdscqsz_attr =
 905         __ATTR(rxdscqsz, 0444, igb_rxdscqsz, igb_store);
 906 static struct kobj_attribute igb_sysfs_txqavg_attr =
 907         __ATTR(txqavg, 0444, igb_txqavg, igb_store);
 908 static struct kobj_attribute igb_sysfs_rxqavg_attr =
 909         __ATTR(rxqavg, 0444, igb_rxqavg, igb_store);
 910 static struct kobj_attribute igb_sysfs_iovotype_attr =
 911         __ATTR(iovotype, 0444, igb_iovotype, igb_store);
 912 static struct kobj_attribute igb_sysfs_funcnbr_attr =
 913         __ATTR(funcnbr, 0444, igb_funcnbr, igb_store);
 914
 915 /* Add the attributes into an array, to be added to a group */
 916 static struct attribute *therm_attrs[] = {
 917         &igb_sysfs_location_attr.attr,
 918         &igb_sysfs_temp_attr.attr,
 919         &igb_sysfs_cautionthresh_attr.attr,
 920         &igb_sysfs_maxopthresh_attr.attr,
 921         NULL
 922 };
 923
 924 static struct attribute *attrs[] = {
 925         &igb_sysfs_fwbanner_attr.attr,
 926         &igb_sysfs_numeports_attr.attr,
 927         &igb_sysfs_porttype_attr.attr,
 928         &igb_sysfs_portspeed_attr.attr,
 929         &igb_sysfs_wqlflag_attr.attr,
 930         &igb_sysfs_xflowctl_attr.attr,
 931         &igb_sysfs_rxdrops_attr.attr,
 932         &igb_sysfs_rxerrors_attr.attr,
 933         &igb_sysfs_rxupacks_attr.attr,
 934         &igb_sysfs_rxmpacks_attr.attr,
 935         &igb_sysfs_rxbpacks_attr.attr,
 936         &igb_sysfs_txdrops_attr.attr,
 937         &igb_sysfs_txerrors_attr.attr,
 938         &igb_sysfs_txupacks_attr.attr,
 939         &igb_sysfs_txmpacks_attr.attr,
 940         &igb_sysfs_txbpacks_attr.attr,
 941         &igb_sysfs_rxframes_attr.attr,
 942         &igb_sysfs_rxbytes_attr.attr,
 943         &igb_sysfs_txframes_attr.attr,
 944         &igb_sysfs_txbytes_attr.attr,
 945         &igb_sysfs_linkstat_attr.attr,
 946         &igb_sysfs_funcid_attr.attr,
 947         &igb_sysfs_funvers_attr.attr,
 948         &igb_sysfs_macburn_attr.attr,
 949         &igb_sysfs_macadmn_attr.attr,
 950         &igb_sysfs_maclla1_attr.attr,
 951         &igb_sysfs_mtusize_attr.attr,
 952         &igb_sysfs_featflag_attr.attr,
 953         &igb_sysfs_lsominct_attr.attr,
 954         &igb_sysfs_prommode_attr.attr,
 955         &igb_sysfs_txdscqsz_attr.attr,
 956         &igb_sysfs_rxdscqsz_attr.attr,
 957         &igb_sysfs_txqavg_attr.attr,
 958         &igb_sysfs_rxqavg_attr.attr,
 959         &igb_sysfs_iovotype_attr.attr,
 960         &igb_sysfs_funcnbr_attr.attr,
 961         NULL
 962 };
 963
 964 /* add attributes to a group */
 965 static struct attribute_group therm_attr_group = {
 966         .attrs = therm_attrs,
 967 };
 968
 969 /* add attributes to a group */
 970 static struct attribute_group attr_group = {
 971         .attrs = attrs,
 972 };
 973
 974 void igb_del_adapter(struct igb_adapter *adapter)
 975 {
 976         int i;
 977
 978         for (i = 0; i < E1000_MAX_SENSORS; i++) {
 979                 if (adapter->therm_kobj[i] == NULL)
 980                         continue;
 981                 sysfs_remove_group(adapter->therm_kobj[i], &therm_attr_group);
 982                 kobject_put(adapter->therm_kobj[i]);
 983         }
 984         if (adapter->info_kobj != NULL) {
 985                 sysfs_remove_group(adapter->info_kobj, &attr_group);
 986                 kobject_put(adapter->info_kobj);
 987         }
 988 }
 989
 990 /* cleanup goes here */
 991 void igb_sysfs_exit(struct igb_adapter *adapter)
 992 {
 993         igb_del_adapter(adapter);
 994 }
 995
 996 int igb_sysfs_init(struct igb_adapter *adapter)
 997 {
 998         struct net_device *netdev;
 999         int rc = 0;
1000         int i;
1001         char buf[16];
1002
1003         if ( adapter == NULL )
1004                 goto del_adapter;
1005         netdev = adapter->netdev;
1006         if (netdev == NULL)
1007                 goto del_adapter;
1008
1009         adapter->info_kobj = NULL;
1010         for (i = 0; i < E1000_MAX_SENSORS; i++)
1011                 adapter->therm_kobj[i] = NULL;
1012
1013         /* create stats kobj and attribute listings in kobj */
1014         adapter->info_kobj = kobject_create_and_add("info",
1015                                         &(netdev->dev.kobj));
1016         if (adapter->info_kobj == NULL)
1017                 goto del_adapter;
1018         if (sysfs_create_group(adapter->info_kobj, &attr_group))
1019                 goto del_adapter;
1020
1021         /* Don't create thermal subkobjs if no data present */
1022         if (igb_thermal_present(adapter->info_kobj) != true)
1023                 goto exit;
1024
1025         for (i = 0; i < E1000_MAX_SENSORS; i++) {
1026
1027                 /*
1028                  * Likewise only create individual kobjs that have
1029                  * meaningful data.
1030                  */
1031                 if (adapter->hw.mac.thermal_sensor_data.sensor[i].location == 0)
1032                         continue;
1033
1034                 /* directory named after sensor offset */
1035                 snprintf(buf, sizeof(buf), "sensor_%d", i);
1036                 adapter->therm_kobj[i] =
1037                         kobject_create_and_add(buf, adapter->info_kobj);
1038                 if (adapter->therm_kobj[i] == NULL)
1039                         goto del_adapter;
1040                 if (sysfs_create_group(adapter->therm_kobj[i],
1041                                        &therm_attr_group))
1042                         goto del_adapter;
1043         }
1044
1045         goto exit;
1046
1047 del_adapter:
1048         igb_del_adapter(adapter);
1049         rc = -1;
1050 exit:
1051         return rc;
1052 }
1053
1054 #endif /* IGB_SYSFS */