1 /*******************************************************************************
3 Intel(R) Gigabit Ethernet Linux driver
4 Copyright(c) 2007-2012 Intel Corporation.
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.
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
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.
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
23 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
24 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26 *******************************************************************************/
29 #include "e1000_82575.h"
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>
39 static struct net_device_stats *sysfs_get_stats(struct net_device *netdev)
41 #ifndef HAVE_NETDEV_STATS_IN_NETDEV
42 struct igb_adapter *adapter;
47 #ifdef HAVE_NETDEV_STATS_IN_NETDEV
48 /* only return the current stats */
49 return &netdev->stats;
51 adapter = netdev_priv(netdev);
53 /* only return the current stats */
54 return &adapter->net_stats;
55 #endif /* HAVE_NETDEV_STATS_IN_NETDEV */
58 struct net_device *igb_get_netdev(struct kobject *kobj)
60 struct net_device *netdev;
61 struct kobject *parent = kobj->parent;
62 struct device *device_info_kobj;
67 device_info_kobj = container_of(parent, struct device, kobj);
68 if (device_info_kobj == NULL)
71 netdev = container_of(device_info_kobj, struct net_device, dev);
74 struct igb_adapter *igb_get_adapter(struct kobject *kobj)
76 struct igb_adapter *adapter;
77 struct net_device *netdev = igb_get_netdev(kobj);
80 adapter = netdev_priv(netdev);
84 bool igb_thermal_present(struct kobject *kobj)
87 struct igb_adapter *adapter = igb_get_adapter(kobj);
93 * Only set I2C bit-bang mode if an external thermal sensor is
94 * supported on this device.
97 status = e1000_set_i2c_bb(&(adapter->hw));
98 if (status != E1000_SUCCESS)
102 status = e1000_init_thermal_sensor_thresh(&(adapter->hw));
103 if (status != E1000_SUCCESS)
110 * Convert the directory to the sensor offset.
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.
115 static int igb_name_to_idx(const char *c) {
117 /* find first digit */
118 while (*c < '0' || *c > '9') {
124 return ((int)(*c - '0'));
128 * We are a statistics entry; we do not take in data-this should be the
129 * same for all attributes
131 static ssize_t igb_store(struct kobject *kobj,
132 struct kobj_attribute *attr,
133 const char *buf, size_t count)
138 static ssize_t igb_fwbanner(struct kobject *kobj,
139 struct kobj_attribute *attr, char *buf)
141 struct igb_adapter *adapter = igb_get_adapter(kobj);
145 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
146 nvm_ver = adapter->fw_version;
148 return snprintf(buf, PAGE_SIZE, "0x%08x\n", nvm_ver);
151 static ssize_t igb_numeports(struct kobject *kobj,
152 struct kobj_attribute *attr, char *buf)
156 struct igb_adapter *adapter = igb_get_adapter(kobj);
158 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
162 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
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.
168 switch (hw->mac.type) {
183 return snprintf(buf, PAGE_SIZE, "%d\n", ports);
186 static ssize_t igb_porttype(struct kobject *kobj,
187 struct kobj_attribute *attr, char *buf)
189 struct igb_adapter *adapter = igb_get_adapter(kobj);
191 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
193 return snprintf(buf, PAGE_SIZE, "%d\n",
194 test_bit(__IGB_DOWN, &adapter->state));
197 static ssize_t igb_portspeed(struct kobject *kobj,
198 struct kobj_attribute *attr, char *buf)
200 struct igb_adapter *adapter = igb_get_adapter(kobj);
204 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
206 switch (adapter->link_speed) {
207 case E1000_STATUS_SPEED_10:
210 case E1000_STATUS_SPEED_100:
213 case E1000_STATUS_SPEED_1000:
217 return snprintf(buf, PAGE_SIZE, "%d\n", speed);
220 static ssize_t igb_wqlflag(struct kobject *kobj,
221 struct kobj_attribute *attr, char *buf)
223 struct igb_adapter *adapter = igb_get_adapter(kobj);
225 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
227 return snprintf(buf, PAGE_SIZE, "%d\n", adapter->wol);
230 static ssize_t igb_xflowctl(struct kobject *kobj,
231 struct kobj_attribute *attr, char *buf)
234 struct igb_adapter *adapter = igb_get_adapter(kobj);
236 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
240 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
242 return snprintf(buf, PAGE_SIZE, "%d\n", hw->fc.current_mode);
245 static ssize_t igb_rxdrops(struct kobject *kobj,
246 struct kobj_attribute *attr, char *buf)
248 struct net_device_stats *net_stats;
249 struct net_device *netdev = igb_get_netdev(kobj);
251 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
253 net_stats = sysfs_get_stats(netdev);
254 if (net_stats == NULL)
255 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
257 return snprintf(buf, PAGE_SIZE, "%lu\n",
258 net_stats->rx_dropped);
261 static ssize_t igb_rxerrors(struct kobject *kobj,
262 struct kobj_attribute *attr, char *buf)
264 struct net_device_stats *net_stats;
265 struct net_device *netdev = igb_get_netdev(kobj);
267 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
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);
275 static ssize_t igb_rxupacks(struct kobject *kobj,
276 struct kobj_attribute *attr, char *buf)
279 struct igb_adapter *adapter = igb_get_adapter(kobj);
281 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
285 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
287 return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_TPR));
290 static ssize_t igb_rxmpacks(struct kobject *kobj,
291 struct kobj_attribute *attr, char *buf)
294 struct igb_adapter *adapter = igb_get_adapter(kobj);
296 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
300 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
302 return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_MPRC));
305 static ssize_t igb_rxbpacks(struct kobject *kobj,
306 struct kobj_attribute *attr, char *buf)
309 struct igb_adapter *adapter = igb_get_adapter(kobj);
311 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
315 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
317 return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_BPRC));
320 static ssize_t igb_txupacks(struct kobject *kobj,
321 struct kobj_attribute *attr, char *buf)
324 struct igb_adapter *adapter = igb_get_adapter(kobj);
326 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
330 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
332 return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_TPT));
335 static ssize_t igb_txmpacks(struct kobject *kobj,
336 struct kobj_attribute *attr, char *buf)
339 struct igb_adapter *adapter = igb_get_adapter(kobj);
341 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
345 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
347 return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_MPTC));
350 static ssize_t igb_txbpacks(struct kobject *kobj,
351 struct kobj_attribute *attr, char *buf)
354 struct igb_adapter *adapter = igb_get_adapter(kobj);
356 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
360 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
362 return snprintf(buf, PAGE_SIZE, "%d\n", E1000_READ_REG(hw, E1000_BPTC));
366 static ssize_t igb_txerrors(struct kobject *kobj,
367 struct kobj_attribute *attr, char *buf)
369 struct net_device_stats *net_stats;
370 struct net_device *netdev = igb_get_netdev(kobj);
372 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
374 net_stats = sysfs_get_stats(netdev);
375 if (net_stats == NULL)
376 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
378 return snprintf(buf, PAGE_SIZE, "%lu\n",
379 net_stats->tx_errors);
382 static ssize_t igb_txdrops(struct kobject *kobj,
383 struct kobj_attribute *attr, char *buf)
385 struct net_device_stats *net_stats;
386 struct net_device *netdev = igb_get_netdev(kobj);
388 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
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);
397 static ssize_t igb_rxframes(struct kobject *kobj,
398 struct kobj_attribute *attr, char *buf)
400 struct net_device_stats *net_stats;
401 struct net_device *netdev = igb_get_netdev(kobj);
403 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
405 net_stats = sysfs_get_stats(netdev);
406 if (net_stats == NULL)
407 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
409 return snprintf(buf, PAGE_SIZE, "%lu\n",
410 net_stats->rx_packets);
413 static ssize_t igb_rxbytes(struct kobject *kobj,
414 struct kobj_attribute *attr, char *buf)
416 struct net_device_stats *net_stats;
417 struct net_device *netdev = igb_get_netdev(kobj);
419 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
421 net_stats = sysfs_get_stats(netdev);
422 if (net_stats == NULL)
423 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
425 return snprintf(buf, PAGE_SIZE, "%lu\n",
426 net_stats->rx_bytes);
429 static ssize_t igb_txframes(struct kobject *kobj,
430 struct kobj_attribute *attr, char *buf)
432 struct net_device_stats *net_stats;
433 struct net_device *netdev = igb_get_netdev(kobj);
435 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
437 net_stats = sysfs_get_stats(netdev);
438 if (net_stats == NULL)
439 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
441 return snprintf(buf, PAGE_SIZE, "%lu\n",
442 net_stats->tx_packets);
445 static ssize_t igb_txbytes(struct kobject *kobj,
446 struct kobj_attribute *attr, char *buf)
448 struct net_device_stats *net_stats;
449 struct net_device *netdev = igb_get_netdev(kobj);
451 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
453 net_stats = sysfs_get_stats(netdev);
454 if (net_stats == NULL)
455 return snprintf(buf, PAGE_SIZE, "error: no net stats\n");
457 return snprintf(buf, PAGE_SIZE, "%lu\n",
458 net_stats->tx_bytes);
461 static ssize_t igb_linkstat(struct kobject *kobj,
462 struct kobj_attribute *attr, char *buf)
464 bool link_up = false;
467 struct igb_adapter *adapter = igb_get_adapter(kobj);
469 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
473 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
475 if (test_bit(__IGB_DOWN, &adapter->state))
478 if (hw->mac.ops.check_for_link) {
479 hw->mac.ops.check_for_link(hw);
482 /* always assume link is up, if no check link function */
487 return snprintf(buf, PAGE_SIZE, "0x%X\n", bitmask);
490 static ssize_t igb_funcid(struct kobject *kobj,
491 struct kobj_attribute *attr, char *buf)
493 struct net_device *netdev = igb_get_netdev(kobj);
495 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
497 return snprintf(buf, PAGE_SIZE, "0x%lX\n", netdev->base_addr);
500 static ssize_t igb_funcvers(struct kobject *kobj,
501 struct kobj_attribute *attr, char *buf)
503 return snprintf(buf, PAGE_SIZE, "%s\n", igb_driver_version);
506 static ssize_t igb_macburn(struct kobject *kobj,
507 struct kobj_attribute *attr, char *buf)
510 struct igb_adapter *adapter = igb_get_adapter(kobj);
512 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
516 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
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]);
527 static ssize_t igb_macadmn(struct kobject *kobj,
528 struct kobj_attribute *attr, char *buf)
530 struct igb_adapter *adapter = igb_get_adapter(kobj);
534 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
538 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
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]);
549 static ssize_t igb_maclla1(struct kobject *kobj,
550 struct kobj_attribute *attr, char *buf)
554 int first_word = 0x37;
558 struct igb_adapter *adapter = igb_get_adapter(kobj);
560 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
564 return snprintf(buf, PAGE_SIZE, "error: no hw data\n");
568 rc = e1000_read_nvm(hw, first_word, word_count,
570 if (rc != E1000_SUCCESS)
573 switch (hw->bus.func) {
575 return snprintf(buf, PAGE_SIZE, "0x%04X%04X%04X\n",
576 eeprom_buff[0], eeprom_buff[1], eeprom_buff[2]);
578 return snprintf(buf, PAGE_SIZE, "0x%04X%04X%04X\n",
579 eeprom_buff[3], eeprom_buff[4], eeprom_buff[5]);
581 return snprintf(buf, PAGE_SIZE, "unexpected port %d\n", hw->bus.func);
584 static ssize_t igb_mtusize(struct kobject *kobj,
585 struct kobj_attribute *attr, char *buf)
587 struct igb_adapter *adapter = igb_get_adapter(kobj);
588 struct net_device *netdev = igb_get_netdev(kobj);
590 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
593 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
595 return snprintf(buf, PAGE_SIZE, "%d\n", netdev->mtu);
598 static ssize_t igb_featflag(struct kobject *kobj,
599 struct kobj_attribute *attr, char *buf)
601 #ifdef HAVE_NDO_SET_FEATURES
604 struct net_device *netdev = igb_get_netdev(kobj);
605 struct igb_adapter *adapter = igb_get_adapter(kobj);
608 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
610 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
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));
618 if (netdev->features & NETIF_F_RXCSUM)
620 return snprintf(buf, PAGE_SIZE, "%d\n", bitmask);
624 static ssize_t igb_lsominct(struct kobject *kobj,
625 struct kobj_attribute *attr, char *buf)
627 return snprintf(buf, PAGE_SIZE, "%d\n", 1);
630 static ssize_t igb_prommode(struct kobject *kobj,
631 struct kobj_attribute *attr, char *buf)
633 struct net_device *netdev = igb_get_netdev(kobj);
635 return snprintf(buf, PAGE_SIZE, "error: no net device\n");
637 return snprintf(buf, PAGE_SIZE, "%d\n",
638 netdev->flags & IFF_PROMISC);
641 static ssize_t igb_txdscqsz(struct kobject *kobj,
642 struct kobj_attribute *attr, char *buf)
644 struct igb_adapter *adapter = igb_get_adapter(kobj);
646 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
648 return snprintf(buf, PAGE_SIZE, "%d\n", adapter->tx_ring[0]->count);
651 static ssize_t igb_rxdscqsz(struct kobject *kobj,
652 struct kobj_attribute *attr, char *buf)
654 struct igb_adapter *adapter = igb_get_adapter(kobj);
656 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
658 return snprintf(buf, PAGE_SIZE, "%d\n", adapter->rx_ring[0]->count);
661 static ssize_t igb_rxqavg(struct kobject *kobj,
662 struct kobj_attribute *attr, char *buf)
668 struct igb_adapter *adapter = igb_get_adapter(kobj);
670 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
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;
679 diff += (adapter->rx_ring[index]->count - ntu + ntc);
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);
688 static ssize_t igb_txqavg(struct kobject *kobj,
689 struct kobj_attribute *attr, char *buf)
695 struct igb_adapter *adapter = igb_get_adapter(kobj);
697 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
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;
706 diff += (adapter->tx_ring[index]->count - ntu + ntc);
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);
716 static ssize_t igb_iovotype(struct kobject *kobj,
717 struct kobj_attribute *attr, char *buf)
719 return snprintf(buf, PAGE_SIZE, "2\n");
722 static ssize_t igb_funcnbr(struct kobject *kobj,
723 struct kobj_attribute *attr, char *buf)
725 struct igb_adapter *adapter = igb_get_adapter(kobj);
727 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
729 return snprintf(buf, PAGE_SIZE, "%d\n", adapter->vfs_allocated_count);
732 s32 igb_sysfs_get_thermal_data(struct kobject *kobj, char *buf)
735 struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
737 if (adapter == NULL) {
738 snprintf(buf, PAGE_SIZE, "error: missing adapter\n");
742 if (&adapter->hw == NULL) {
743 snprintf(buf, PAGE_SIZE, "error: missing hw\n");
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);
754 static ssize_t igb_sysfs_location(struct kobject *kobj,
755 struct kobj_attribute *attr,
758 struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
762 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
764 idx = igb_name_to_idx(kobj->name);
766 return snprintf(buf, PAGE_SIZE,
767 "error: invalid sensor name %s\n", kobj->name);
769 return snprintf(buf, PAGE_SIZE, "%d\n",
770 adapter->hw.mac.thermal_sensor_data.sensor[idx].location);
773 static ssize_t igb_sysfs_temp(struct kobject *kobj,
774 struct kobj_attribute *attr,
777 struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
780 s32 status = igb_sysfs_get_thermal_data(kobj, buf);
782 if (status != E1000_SUCCESS)
783 return snprintf(buf, PAGE_SIZE, "error: status %d returned",
786 idx = igb_name_to_idx(kobj->name);
788 return snprintf(buf, PAGE_SIZE,
789 "error: invalid sensor name %s\n", kobj->name);
791 return snprintf(buf, PAGE_SIZE, "%d\n",
792 adapter->hw.mac.thermal_sensor_data.sensor[idx].temp);
795 static ssize_t igb_sysfs_maxopthresh(struct kobject *kobj,
796 struct kobj_attribute *attr,
799 struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
802 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
804 idx = igb_name_to_idx(kobj->name);
806 return snprintf(buf, PAGE_SIZE,
807 "error: invalid sensor name %s\n", kobj->name);
809 return snprintf(buf, PAGE_SIZE, "%d\n",
810 adapter->hw.mac.thermal_sensor_data.sensor[idx].max_op_thresh);
813 static ssize_t igb_sysfs_cautionthresh(struct kobject *kobj,
814 struct kobj_attribute *attr,
817 struct igb_adapter *adapter = igb_get_adapter(kobj->parent);
821 return snprintf(buf, PAGE_SIZE, "error: no adapter\n");
823 idx = igb_name_to_idx(kobj->name);
825 return snprintf(buf, PAGE_SIZE,
826 "error: invalid sensor name %s\n", kobj->name);
828 return snprintf(buf, PAGE_SIZE, "%d\n",
829 adapter->hw.mac.thermal_sensor_data.sensor[0].caution_thresh);
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);
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);
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,
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,
964 /* add attributes to a group */
965 static struct attribute_group therm_attr_group = {
966 .attrs = therm_attrs,
969 /* add attributes to a group */
970 static struct attribute_group attr_group = {
974 void igb_del_adapter(struct igb_adapter *adapter)
978 for (i = 0; i < E1000_MAX_SENSORS; i++) {
979 if (adapter->therm_kobj[i] == NULL)
981 sysfs_remove_group(adapter->therm_kobj[i], &therm_attr_group);
982 kobject_put(adapter->therm_kobj[i]);
984 if (adapter->info_kobj != NULL) {
985 sysfs_remove_group(adapter->info_kobj, &attr_group);
986 kobject_put(adapter->info_kobj);
990 /* cleanup goes here */
991 void igb_sysfs_exit(struct igb_adapter *adapter)
993 igb_del_adapter(adapter);
996 int igb_sysfs_init(struct igb_adapter *adapter)
998 struct net_device *netdev;
1003 if ( adapter == NULL )
1005 netdev = adapter->netdev;
1009 adapter->info_kobj = NULL;
1010 for (i = 0; i < E1000_MAX_SENSORS; i++)
1011 adapter->therm_kobj[i] = NULL;
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)
1018 if (sysfs_create_group(adapter->info_kobj, &attr_group))
1021 /* Don't create thermal subkobjs if no data present */
1022 if (igb_thermal_present(adapter->info_kobj) != true)
1025 for (i = 0; i < E1000_MAX_SENSORS; i++) {
1028 * Likewise only create individual kobjs that have
1031 if (adapter->hw.mac.thermal_sensor_data.sensor[i].location == 0)
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)
1040 if (sysfs_create_group(adapter->therm_kobj[i],
1048 igb_del_adapter(adapter);
1054 #endif /* IGB_SYSFS */