1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright 2017 Ben Whitten <ben.whitten@gmail.com> 3 // Copyright 2007 Oliver Jowett <oliver@opencloud.com> 4 // 5 // LED Kernel Netdev Trigger 6 // 7 // Toggles the LED to reflect the link and traffic state of a named net device 8 // 9 // Derived from ledtrig-timer.c which is: 10 // Copyright 2005-2006 Openedhand Ltd. 11 // Author: Richard Purdie <rpurdie@openedhand.com> 12 13 #include <linux/atomic.h> 14 #include <linux/ctype.h> 15 #include <linux/device.h> 16 #include <linux/ethtool.h> 17 #include <linux/init.h> 18 #include <linux/jiffies.h> 19 #include <linux/kernel.h> 20 #include <linux/leds.h> 21 #include <linux/linkmode.h> 22 #include <linux/list.h> 23 #include <linux/module.h> 24 #include <linux/netdevice.h> 25 #include <linux/mutex.h> 26 #include <linux/phy.h> 27 #include <linux/rtnetlink.h> 28 #include <linux/timer.h> 29 #include "../leds.h" 30 31 #define NETDEV_LED_DEFAULT_INTERVAL 50 32 33 /* 34 * Configurable sysfs attributes: 35 * 36 * device_name - network device name to monitor 37 * interval - duration of LED blink, in milliseconds 38 * link - LED's normal state reflects whether the link is up 39 * (has carrier) or not 40 * tx - LED blinks on transmitted data 41 * rx - LED blinks on receive data 42 * tx_err - LED blinks on transmit error 43 * rx_err - LED blinks on receive error 44 * 45 * Note: If the user selects a mode that is not supported by hw, default 46 * behavior is to fall back to software control of the LED. However not every 47 * hw supports software control. LED callbacks brightness_set() and 48 * brightness_set_blocking() are NULL in this case. hw_control_is_supported() 49 * should use available means supported by hw to inform the user that selected 50 * mode isn't supported by hw. This could be switching off the LED or any 51 * hw blink mode. If software control fallback isn't possible, we return 52 * -EOPNOTSUPP to the user, but still store the selected mode. This is needed 53 * in case an intermediate unsupported mode is necessary to switch from one 54 * supported mode to another. 55 */ 56 57 struct led_netdev_data { 58 struct mutex lock; 59 60 struct delayed_work work; 61 struct notifier_block notifier; 62 63 struct led_classdev *led_cdev; 64 struct net_device *net_dev; 65 66 char device_name[IFNAMSIZ]; 67 atomic_t interval; 68 unsigned int last_activity; 69 70 unsigned long mode; 71 unsigned long blink_delay; 72 int link_speed; 73 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported_link_modes); 74 u8 duplex; 75 76 bool carrier_link_up; 77 bool hw_control; 78 }; 79 80 static const struct attribute_group netdev_trig_link_speed_attrs_group; 81 82 static void set_baseline_state(struct led_netdev_data *trigger_data) 83 { 84 int current_brightness; 85 struct led_classdev *led_cdev = trigger_data->led_cdev; 86 87 /* Already validated, hw control is possible with the requested mode */ 88 if (trigger_data->hw_control) { 89 led_cdev->hw_control_set(led_cdev, trigger_data->mode); 90 if (led_cdev->blink_set) { 91 led_cdev->blink_set(led_cdev, &trigger_data->blink_delay, 92 &trigger_data->blink_delay); 93 } 94 95 return; 96 } 97 98 current_brightness = led_cdev->brightness; 99 if (current_brightness) 100 led_cdev->blink_brightness = current_brightness; 101 if (!led_cdev->blink_brightness) 102 led_cdev->blink_brightness = led_cdev->max_brightness; 103 104 if (!trigger_data->carrier_link_up) { 105 led_set_brightness(led_cdev, LED_OFF); 106 } else { 107 bool blink_on = false; 108 109 if (test_bit(TRIGGER_NETDEV_LINK, &trigger_data->mode)) 110 blink_on = true; 111 112 if (test_bit(TRIGGER_NETDEV_LINK_10, &trigger_data->mode) && 113 trigger_data->link_speed == SPEED_10) 114 blink_on = true; 115 116 if (test_bit(TRIGGER_NETDEV_LINK_100, &trigger_data->mode) && 117 trigger_data->link_speed == SPEED_100) 118 blink_on = true; 119 120 if (test_bit(TRIGGER_NETDEV_LINK_1000, &trigger_data->mode) && 121 trigger_data->link_speed == SPEED_1000) 122 blink_on = true; 123 124 if (test_bit(TRIGGER_NETDEV_LINK_2500, &trigger_data->mode) && 125 trigger_data->link_speed == SPEED_2500) 126 blink_on = true; 127 128 if (test_bit(TRIGGER_NETDEV_LINK_5000, &trigger_data->mode) && 129 trigger_data->link_speed == SPEED_5000) 130 blink_on = true; 131 132 if (test_bit(TRIGGER_NETDEV_LINK_10000, &trigger_data->mode) && 133 trigger_data->link_speed == SPEED_10000) 134 blink_on = true; 135 136 if (test_bit(TRIGGER_NETDEV_HALF_DUPLEX, &trigger_data->mode) && 137 trigger_data->duplex == DUPLEX_HALF) 138 blink_on = true; 139 140 if (test_bit(TRIGGER_NETDEV_FULL_DUPLEX, &trigger_data->mode) && 141 trigger_data->duplex == DUPLEX_FULL) 142 blink_on = true; 143 144 if (blink_on) 145 led_set_brightness(led_cdev, 146 led_cdev->blink_brightness); 147 else 148 led_set_brightness(led_cdev, LED_OFF); 149 150 /* If we are looking for RX/TX start periodically 151 * checking stats 152 */ 153 if (test_bit(TRIGGER_NETDEV_TX, &trigger_data->mode) || 154 test_bit(TRIGGER_NETDEV_RX, &trigger_data->mode) || 155 test_bit(TRIGGER_NETDEV_TX_ERR, &trigger_data->mode) || 156 test_bit(TRIGGER_NETDEV_RX_ERR, &trigger_data->mode)) 157 schedule_delayed_work(&trigger_data->work, 0); 158 } 159 } 160 161 static bool supports_hw_control(struct led_classdev *led_cdev) 162 { 163 if (!led_cdev->hw_control_get || !led_cdev->hw_control_set || 164 !led_cdev->hw_control_is_supported) 165 return false; 166 167 return !strcmp(led_cdev->hw_control_trigger, led_cdev->trigger->name); 168 } 169 170 /* 171 * Validate the configured netdev is the same as the one associated with 172 * the LED driver in hw control. 173 */ 174 static bool validate_net_dev(struct led_classdev *led_cdev, 175 struct net_device *net_dev) 176 { 177 struct device *dev = led_cdev->hw_control_get_device(led_cdev); 178 struct net_device *ndev; 179 180 if (!dev) 181 return false; 182 183 ndev = to_net_dev(dev); 184 185 return ndev == net_dev; 186 } 187 188 static bool can_hw_control(struct led_netdev_data *trigger_data) 189 { 190 unsigned long default_interval = msecs_to_jiffies(NETDEV_LED_DEFAULT_INTERVAL); 191 unsigned int interval = atomic_read(&trigger_data->interval); 192 struct led_classdev *led_cdev = trigger_data->led_cdev; 193 int ret; 194 195 if (!supports_hw_control(led_cdev)) 196 return false; 197 198 /* 199 * Interval must be set to the default 200 * value. Any different value is rejected if in hw 201 * control. 202 */ 203 if (interval != default_interval) 204 return false; 205 206 /* 207 * net_dev must be set with hw control, otherwise no 208 * blinking can be happening and there is nothing to 209 * offloaded. Additionally, for hw control to be 210 * valid, the configured netdev must be the same as 211 * netdev associated to the LED. 212 */ 213 if (!validate_net_dev(led_cdev, trigger_data->net_dev)) 214 return false; 215 216 /* Check if the requested mode is supported */ 217 ret = led_cdev->hw_control_is_supported(led_cdev, trigger_data->mode); 218 /* Fall back to software blinking if not supported */ 219 if (ret == -EOPNOTSUPP) 220 return false; 221 if (ret) { 222 dev_warn(led_cdev->dev, 223 "Current mode check failed with error %d\n", ret); 224 return false; 225 } 226 227 return true; 228 } 229 230 static void get_device_state(struct led_netdev_data *trigger_data) 231 { 232 struct ethtool_link_ksettings cmd; 233 234 trigger_data->carrier_link_up = netif_carrier_ok(trigger_data->net_dev); 235 236 if (__ethtool_get_link_ksettings(trigger_data->net_dev, &cmd)) 237 return; 238 239 if (trigger_data->carrier_link_up) { 240 trigger_data->link_speed = cmd.base.speed; 241 trigger_data->duplex = cmd.base.duplex; 242 } 243 244 /* 245 * Have a local copy of the link speed supported to avoid rtnl lock every time 246 * modes are refreshed on any change event 247 */ 248 linkmode_copy(trigger_data->supported_link_modes, cmd.link_modes.supported); 249 } 250 251 static ssize_t device_name_show(struct device *dev, 252 struct device_attribute *attr, char *buf) 253 { 254 struct led_netdev_data *trigger_data = led_trigger_get_drvdata(dev); 255 ssize_t len; 256 257 mutex_lock(&trigger_data->lock); 258 len = sprintf(buf, "%s\n", trigger_data->device_name); 259 mutex_unlock(&trigger_data->lock); 260 261 return len; 262 } 263 264 static int set_device_name(struct led_netdev_data *trigger_data, 265 const char *name, size_t size) 266 { 267 if (size >= IFNAMSIZ) 268 return -EINVAL; 269 270 cancel_delayed_work_sync(&trigger_data->work); 271 272 /* 273 * Take RTNL lock before trigger_data lock to prevent potential 274 * deadlock with netdev notifier registration. 275 */ 276 rtnl_lock(); 277 mutex_lock(&trigger_data->lock); 278 279 if (trigger_data->net_dev) { 280 dev_put(trigger_data->net_dev); 281 trigger_data->net_dev = NULL; 282 } 283 284 memcpy(trigger_data->device_name, name, size); 285 trigger_data->device_name[size] = 0; 286 if (size > 0 && trigger_data->device_name[size - 1] == '\n') 287 trigger_data->device_name[size - 1] = 0; 288 289 if (trigger_data->device_name[0] != 0) 290 trigger_data->net_dev = 291 dev_get_by_name(&init_net, trigger_data->device_name); 292 293 trigger_data->carrier_link_up = false; 294 trigger_data->link_speed = SPEED_UNKNOWN; 295 trigger_data->duplex = DUPLEX_UNKNOWN; 296 if (trigger_data->net_dev) 297 get_device_state(trigger_data); 298 299 trigger_data->last_activity = 0; 300 301 /* Skip if we're called from netdev_trig_activate() and hw_control is true */ 302 if (!trigger_data->hw_control || led_get_trigger_data(trigger_data->led_cdev)) 303 set_baseline_state(trigger_data); 304 305 mutex_unlock(&trigger_data->lock); 306 rtnl_unlock(); 307 308 return 0; 309 } 310 311 static ssize_t device_name_store(struct device *dev, 312 struct device_attribute *attr, const char *buf, 313 size_t size) 314 { 315 struct led_netdev_data *trigger_data = led_trigger_get_drvdata(dev); 316 int ret; 317 318 ret = set_device_name(trigger_data, buf, size); 319 320 if (ret < 0) 321 return ret; 322 323 /* Refresh link_speed visibility */ 324 sysfs_update_group(&dev->kobj, &netdev_trig_link_speed_attrs_group); 325 326 return size; 327 } 328 329 static DEVICE_ATTR_RW(device_name); 330 331 static ssize_t netdev_led_attr_show(struct device *dev, char *buf, 332 enum led_trigger_netdev_modes attr) 333 { 334 struct led_netdev_data *trigger_data = led_trigger_get_drvdata(dev); 335 int bit; 336 337 switch (attr) { 338 case TRIGGER_NETDEV_LINK: 339 case TRIGGER_NETDEV_LINK_10: 340 case TRIGGER_NETDEV_LINK_100: 341 case TRIGGER_NETDEV_LINK_1000: 342 case TRIGGER_NETDEV_LINK_2500: 343 case TRIGGER_NETDEV_LINK_5000: 344 case TRIGGER_NETDEV_LINK_10000: 345 case TRIGGER_NETDEV_HALF_DUPLEX: 346 case TRIGGER_NETDEV_FULL_DUPLEX: 347 case TRIGGER_NETDEV_TX: 348 case TRIGGER_NETDEV_RX: 349 case TRIGGER_NETDEV_TX_ERR: 350 case TRIGGER_NETDEV_RX_ERR: 351 bit = attr; 352 break; 353 default: 354 return -EINVAL; 355 } 356 357 return sprintf(buf, "%u\n", test_bit(bit, &trigger_data->mode)); 358 } 359 360 static ssize_t netdev_led_attr_store(struct device *dev, const char *buf, 361 size_t size, enum led_trigger_netdev_modes attr) 362 { 363 struct led_netdev_data *trigger_data = led_trigger_get_drvdata(dev); 364 struct led_classdev *led_cdev = trigger_data->led_cdev; 365 unsigned long state, mode = trigger_data->mode; 366 int ret; 367 int bit; 368 369 ret = kstrtoul(buf, 0, &state); 370 if (ret) 371 return ret; 372 373 switch (attr) { 374 case TRIGGER_NETDEV_LINK: 375 case TRIGGER_NETDEV_LINK_10: 376 case TRIGGER_NETDEV_LINK_100: 377 case TRIGGER_NETDEV_LINK_1000: 378 case TRIGGER_NETDEV_LINK_2500: 379 case TRIGGER_NETDEV_LINK_5000: 380 case TRIGGER_NETDEV_LINK_10000: 381 case TRIGGER_NETDEV_HALF_DUPLEX: 382 case TRIGGER_NETDEV_FULL_DUPLEX: 383 case TRIGGER_NETDEV_TX: 384 case TRIGGER_NETDEV_RX: 385 case TRIGGER_NETDEV_TX_ERR: 386 case TRIGGER_NETDEV_RX_ERR: 387 bit = attr; 388 break; 389 default: 390 return -EINVAL; 391 } 392 393 if (state) 394 set_bit(bit, &mode); 395 else 396 clear_bit(bit, &mode); 397 398 if (test_bit(TRIGGER_NETDEV_LINK, &mode) && 399 (test_bit(TRIGGER_NETDEV_LINK_10, &mode) || 400 test_bit(TRIGGER_NETDEV_LINK_100, &mode) || 401 test_bit(TRIGGER_NETDEV_LINK_1000, &mode) || 402 test_bit(TRIGGER_NETDEV_LINK_2500, &mode) || 403 test_bit(TRIGGER_NETDEV_LINK_5000, &mode) || 404 test_bit(TRIGGER_NETDEV_LINK_10000, &mode))) 405 return -EINVAL; 406 407 cancel_delayed_work_sync(&trigger_data->work); 408 409 trigger_data->mode = mode; 410 trigger_data->hw_control = can_hw_control(trigger_data); 411 412 if (!led_cdev->brightness_set && !led_cdev->brightness_set_blocking && 413 !trigger_data->hw_control) 414 return -EOPNOTSUPP; 415 416 set_baseline_state(trigger_data); 417 418 return size; 419 } 420 421 #define DEFINE_NETDEV_TRIGGER(trigger_name, trigger) \ 422 static ssize_t trigger_name##_show(struct device *dev, \ 423 struct device_attribute *attr, char *buf) \ 424 { \ 425 return netdev_led_attr_show(dev, buf, trigger); \ 426 } \ 427 static ssize_t trigger_name##_store(struct device *dev, \ 428 struct device_attribute *attr, const char *buf, size_t size) \ 429 { \ 430 return netdev_led_attr_store(dev, buf, size, trigger); \ 431 } \ 432 static DEVICE_ATTR_RW(trigger_name) 433 434 DEFINE_NETDEV_TRIGGER(link, TRIGGER_NETDEV_LINK); 435 DEFINE_NETDEV_TRIGGER(link_10, TRIGGER_NETDEV_LINK_10); 436 DEFINE_NETDEV_TRIGGER(link_100, TRIGGER_NETDEV_LINK_100); 437 DEFINE_NETDEV_TRIGGER(link_1000, TRIGGER_NETDEV_LINK_1000); 438 DEFINE_NETDEV_TRIGGER(link_2500, TRIGGER_NETDEV_LINK_2500); 439 DEFINE_NETDEV_TRIGGER(link_5000, TRIGGER_NETDEV_LINK_5000); 440 DEFINE_NETDEV_TRIGGER(link_10000, TRIGGER_NETDEV_LINK_10000); 441 DEFINE_NETDEV_TRIGGER(half_duplex, TRIGGER_NETDEV_HALF_DUPLEX); 442 DEFINE_NETDEV_TRIGGER(full_duplex, TRIGGER_NETDEV_FULL_DUPLEX); 443 DEFINE_NETDEV_TRIGGER(tx, TRIGGER_NETDEV_TX); 444 DEFINE_NETDEV_TRIGGER(rx, TRIGGER_NETDEV_RX); 445 DEFINE_NETDEV_TRIGGER(tx_err, TRIGGER_NETDEV_TX_ERR); 446 DEFINE_NETDEV_TRIGGER(rx_err, TRIGGER_NETDEV_RX_ERR); 447 448 static ssize_t interval_show(struct device *dev, 449 struct device_attribute *attr, char *buf) 450 { 451 struct led_netdev_data *trigger_data = led_trigger_get_drvdata(dev); 452 453 return sprintf(buf, "%u\n", 454 jiffies_to_msecs(atomic_read(&trigger_data->interval))); 455 } 456 457 static ssize_t interval_store(struct device *dev, 458 struct device_attribute *attr, const char *buf, 459 size_t size) 460 { 461 struct led_netdev_data *trigger_data = led_trigger_get_drvdata(dev); 462 struct led_classdev *led_cdev = trigger_data->led_cdev; 463 unsigned long value; 464 int ret; 465 466 if (trigger_data->hw_control && !led_cdev->blink_set) 467 return -EINVAL; 468 469 ret = kstrtoul(buf, 0, &value); 470 if (ret) 471 return ret; 472 473 /* impose some basic bounds on the timer interval */ 474 if (value >= 5 && value <= 10000) { 475 if (trigger_data->hw_control) { 476 trigger_data->blink_delay = value; 477 } else { 478 cancel_delayed_work_sync(&trigger_data->work); 479 480 atomic_set(&trigger_data->interval, msecs_to_jiffies(value)); 481 } 482 set_baseline_state(trigger_data); /* resets timer */ 483 } 484 485 return size; 486 } 487 488 static DEVICE_ATTR_RW(interval); 489 490 static ssize_t offloaded_show(struct device *dev, 491 struct device_attribute *attr, char *buf) 492 { 493 struct led_netdev_data *trigger_data = led_trigger_get_drvdata(dev); 494 495 return sprintf(buf, "%d\n", trigger_data->hw_control); 496 } 497 498 static DEVICE_ATTR_RO(offloaded); 499 500 #define CHECK_LINK_MODE_ATTR(link_speed) \ 501 do { \ 502 if (attr == &dev_attr_link_##link_speed.attr && \ 503 link_ksettings.base.speed == SPEED_##link_speed) \ 504 return attr->mode; \ 505 } while (0) 506 507 static umode_t netdev_trig_link_speed_visible(struct kobject *kobj, 508 struct attribute *attr, int n) 509 { 510 struct device *dev = kobj_to_dev(kobj); 511 struct led_netdev_data *trigger_data; 512 unsigned long *supported_link_modes; 513 u32 mode; 514 515 trigger_data = led_trigger_get_drvdata(dev); 516 supported_link_modes = trigger_data->supported_link_modes; 517 518 /* 519 * Search in the supported link mode mask a matching supported mode. 520 * Stop at the first matching entry as we care only to check if a particular 521 * speed is supported and not the kind. 522 */ 523 for_each_set_bit(mode, supported_link_modes, __ETHTOOL_LINK_MODE_MASK_NBITS) { 524 struct ethtool_link_ksettings link_ksettings; 525 526 ethtool_params_from_link_mode(&link_ksettings, mode); 527 528 CHECK_LINK_MODE_ATTR(10); 529 CHECK_LINK_MODE_ATTR(100); 530 CHECK_LINK_MODE_ATTR(1000); 531 CHECK_LINK_MODE_ATTR(2500); 532 CHECK_LINK_MODE_ATTR(5000); 533 CHECK_LINK_MODE_ATTR(10000); 534 } 535 536 return 0; 537 } 538 539 static struct attribute *netdev_trig_link_speed_attrs[] = { 540 &dev_attr_link_10.attr, 541 &dev_attr_link_100.attr, 542 &dev_attr_link_1000.attr, 543 &dev_attr_link_2500.attr, 544 &dev_attr_link_5000.attr, 545 &dev_attr_link_10000.attr, 546 NULL 547 }; 548 549 static const struct attribute_group netdev_trig_link_speed_attrs_group = { 550 .attrs = netdev_trig_link_speed_attrs, 551 .is_visible = netdev_trig_link_speed_visible, 552 }; 553 554 static struct attribute *netdev_trig_attrs[] = { 555 &dev_attr_device_name.attr, 556 &dev_attr_link.attr, 557 &dev_attr_full_duplex.attr, 558 &dev_attr_half_duplex.attr, 559 &dev_attr_rx.attr, 560 &dev_attr_tx.attr, 561 &dev_attr_rx_err.attr, 562 &dev_attr_tx_err.attr, 563 &dev_attr_interval.attr, 564 &dev_attr_offloaded.attr, 565 NULL 566 }; 567 568 static const struct attribute_group netdev_trig_attrs_group = { 569 .attrs = netdev_trig_attrs, 570 }; 571 572 static const struct attribute_group *netdev_trig_groups[] = { 573 &netdev_trig_attrs_group, 574 &netdev_trig_link_speed_attrs_group, 575 NULL, 576 }; 577 578 static int netdev_trig_notify(struct notifier_block *nb, 579 unsigned long evt, void *dv) 580 { 581 struct net_device *dev = 582 netdev_notifier_info_to_dev((struct netdev_notifier_info *)dv); 583 struct led_netdev_data *trigger_data = 584 container_of(nb, struct led_netdev_data, notifier); 585 struct led_classdev *led_cdev = trigger_data->led_cdev; 586 587 if (evt != NETDEV_UP && evt != NETDEV_DOWN && evt != NETDEV_CHANGE 588 && evt != NETDEV_REGISTER && evt != NETDEV_UNREGISTER 589 && evt != NETDEV_CHANGENAME) 590 return NOTIFY_DONE; 591 592 if (!(dev == trigger_data->net_dev || 593 (evt == NETDEV_CHANGENAME && !strcmp(dev->name, trigger_data->device_name)) || 594 (evt == NETDEV_REGISTER && !strcmp(dev->name, trigger_data->device_name)))) 595 return NOTIFY_DONE; 596 597 cancel_delayed_work_sync(&trigger_data->work); 598 599 mutex_lock(&trigger_data->lock); 600 601 trigger_data->carrier_link_up = false; 602 trigger_data->link_speed = SPEED_UNKNOWN; 603 trigger_data->duplex = DUPLEX_UNKNOWN; 604 switch (evt) { 605 case NETDEV_CHANGENAME: 606 case NETDEV_REGISTER: 607 dev_put(trigger_data->net_dev); 608 dev_hold(dev); 609 trigger_data->net_dev = dev; 610 if (evt == NETDEV_CHANGENAME) 611 get_device_state(trigger_data); 612 break; 613 case NETDEV_UNREGISTER: 614 dev_put(trigger_data->net_dev); 615 trigger_data->net_dev = NULL; 616 break; 617 case NETDEV_UP: 618 trigger_data->hw_control = can_hw_control(trigger_data); 619 fallthrough; 620 case NETDEV_CHANGE: 621 get_device_state(trigger_data); 622 /* Refresh link_speed visibility */ 623 if (evt == NETDEV_CHANGE) 624 sysfs_update_group(&led_cdev->dev->kobj, 625 &netdev_trig_link_speed_attrs_group); 626 break; 627 } 628 629 set_baseline_state(trigger_data); 630 631 mutex_unlock(&trigger_data->lock); 632 633 return NOTIFY_DONE; 634 } 635 636 /* here's the real work! */ 637 static void netdev_trig_work(struct work_struct *work) 638 { 639 struct led_netdev_data *trigger_data = 640 container_of(work, struct led_netdev_data, work.work); 641 struct rtnl_link_stats64 *dev_stats; 642 unsigned int new_activity; 643 struct rtnl_link_stats64 temp; 644 unsigned long interval; 645 int invert; 646 647 /* If we dont have a device, insure we are off */ 648 if (!trigger_data->net_dev) { 649 led_set_brightness(trigger_data->led_cdev, LED_OFF); 650 return; 651 } 652 653 /* If we are not looking for RX/TX then return */ 654 if (!test_bit(TRIGGER_NETDEV_TX, &trigger_data->mode) && 655 !test_bit(TRIGGER_NETDEV_RX, &trigger_data->mode) && 656 !test_bit(TRIGGER_NETDEV_TX_ERR, &trigger_data->mode) && 657 !test_bit(TRIGGER_NETDEV_RX_ERR, &trigger_data->mode)) 658 return; 659 660 dev_stats = dev_get_stats(trigger_data->net_dev, &temp); 661 new_activity = 662 (test_bit(TRIGGER_NETDEV_TX, &trigger_data->mode) ? 663 dev_stats->tx_packets : 0) + 664 (test_bit(TRIGGER_NETDEV_RX, &trigger_data->mode) ? 665 dev_stats->rx_packets : 0) + 666 (test_bit(TRIGGER_NETDEV_TX_ERR, &trigger_data->mode) ? 667 dev_stats->tx_errors : 0) + 668 (test_bit(TRIGGER_NETDEV_RX_ERR, &trigger_data->mode) ? 669 dev_stats->rx_errors : 0); 670 671 if (trigger_data->last_activity != new_activity) { 672 led_stop_software_blink(trigger_data->led_cdev); 673 674 invert = test_bit(TRIGGER_NETDEV_LINK, &trigger_data->mode) || 675 test_bit(TRIGGER_NETDEV_LINK_10, &trigger_data->mode) || 676 test_bit(TRIGGER_NETDEV_LINK_100, &trigger_data->mode) || 677 test_bit(TRIGGER_NETDEV_LINK_1000, &trigger_data->mode) || 678 test_bit(TRIGGER_NETDEV_LINK_2500, &trigger_data->mode) || 679 test_bit(TRIGGER_NETDEV_LINK_5000, &trigger_data->mode) || 680 test_bit(TRIGGER_NETDEV_LINK_10000, &trigger_data->mode) || 681 test_bit(TRIGGER_NETDEV_HALF_DUPLEX, &trigger_data->mode) || 682 test_bit(TRIGGER_NETDEV_FULL_DUPLEX, &trigger_data->mode); 683 interval = jiffies_to_msecs( 684 atomic_read(&trigger_data->interval)); 685 /* base state is ON (link present) */ 686 led_blink_set_oneshot(trigger_data->led_cdev, 687 &interval, 688 &interval, 689 invert); 690 trigger_data->last_activity = new_activity; 691 } 692 693 schedule_delayed_work(&trigger_data->work, 694 (atomic_read(&trigger_data->interval)*2)); 695 } 696 697 static int netdev_trig_activate(struct led_classdev *led_cdev) 698 { 699 struct led_netdev_data *trigger_data; 700 unsigned long mode = 0; 701 struct device *dev; 702 int rc; 703 704 trigger_data = kzalloc(sizeof(struct led_netdev_data), GFP_KERNEL); 705 if (!trigger_data) 706 return -ENOMEM; 707 708 mutex_init(&trigger_data->lock); 709 710 trigger_data->notifier.notifier_call = netdev_trig_notify; 711 trigger_data->notifier.priority = 10; 712 713 INIT_DELAYED_WORK(&trigger_data->work, netdev_trig_work); 714 715 trigger_data->led_cdev = led_cdev; 716 trigger_data->net_dev = NULL; 717 trigger_data->device_name[0] = 0; 718 719 trigger_data->mode = 0; 720 atomic_set(&trigger_data->interval, msecs_to_jiffies(NETDEV_LED_DEFAULT_INTERVAL)); 721 trigger_data->last_activity = 0; 722 723 /* Check if hw control is active by default on the LED. 724 * Init already enabled mode in hw control. 725 */ 726 if (supports_hw_control(led_cdev)) { 727 dev = led_cdev->hw_control_get_device(led_cdev); 728 if (dev) { 729 const char *name = dev_name(dev); 730 731 trigger_data->hw_control = true; 732 set_device_name(trigger_data, name, strlen(name)); 733 734 rc = led_cdev->hw_control_get(led_cdev, &mode); 735 if (!rc) 736 trigger_data->mode = mode; 737 } 738 } 739 740 led_set_trigger_data(led_cdev, trigger_data); 741 742 rc = register_netdevice_notifier(&trigger_data->notifier); 743 if (rc) 744 kfree(trigger_data); 745 746 return rc; 747 } 748 749 static void netdev_trig_deactivate(struct led_classdev *led_cdev) 750 { 751 struct led_netdev_data *trigger_data = led_get_trigger_data(led_cdev); 752 753 unregister_netdevice_notifier(&trigger_data->notifier); 754 755 cancel_delayed_work_sync(&trigger_data->work); 756 757 dev_put(trigger_data->net_dev); 758 759 kfree(trigger_data); 760 } 761 762 static struct led_trigger netdev_led_trigger = { 763 .name = "netdev", 764 .activate = netdev_trig_activate, 765 .deactivate = netdev_trig_deactivate, 766 .groups = netdev_trig_groups, 767 }; 768 769 module_led_trigger(netdev_led_trigger); 770 771 MODULE_AUTHOR("Ben Whitten <ben.whitten@gmail.com>"); 772 MODULE_AUTHOR("Oliver Jowett <oliver@opencloud.com>"); 773 MODULE_DESCRIPTION("Netdev LED trigger"); 774 MODULE_LICENSE("GPL v2"); 775 MODULE_ALIAS("ledtrig:netdev"); 776