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