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
set_baseline_state(struct led_netdev_data * trigger_data)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
supports_hw_control(struct led_classdev * led_cdev)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 */
validate_net_dev(struct led_classdev * led_cdev,struct net_device * net_dev)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
can_hw_control(struct led_netdev_data * trigger_data)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
get_device_state(struct led_netdev_data * trigger_data)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
device_name_show(struct device * dev,struct device_attribute * attr,char * buf)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
set_device_name(struct led_netdev_data * trigger_data,const char * name,size_t size)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
device_name_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)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
netdev_led_attr_show(struct device * dev,char * buf,enum led_trigger_netdev_modes attr)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
netdev_led_attr_store(struct device * dev,const char * buf,size_t size,enum led_trigger_netdev_modes attr)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
interval_show(struct device * dev,struct device_attribute * attr,char * buf)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
interval_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)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
offloaded_show(struct device * dev,struct device_attribute * attr,char * buf)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
netdev_trig_link_speed_visible(struct kobject * kobj,struct attribute * attr,int n)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
netdev_trig_notify(struct notifier_block * nb,unsigned long evt,void * dv)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! */
netdev_trig_work(struct work_struct * 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
netdev_trig_activate(struct led_classdev * led_cdev)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
netdev_trig_deactivate(struct led_classdev * led_cdev)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