root/drivers/net/can/led.c

DEFINITIONS

1. can_led_event
2. can_led_release
3. devm_can_led_init
4. can_led_notifier
5. can_led_notifier_init
6. can_led_notifier_exit

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
   4  * Copyright 2012, Kurt Van Dijck <kurt.van.dijck@eia.be>
   5  */
   6 
   7 #include <linux/module.h>
   8 #include <linux/device.h>
   9 #include <linux/kernel.h>
  10 #include <linux/slab.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/can/dev.h>
  13 
  14 #include <linux/can/led.h>
  15 
  16 static unsigned long led_delay = 50;
  17 module_param(led_delay, ulong, 0644);
  18 MODULE_PARM_DESC(led_delay,
  19                 "blink delay time for activity leds (msecs, default: 50).");
  20 
  21 /* Trigger a LED event in response to a CAN device event */
  22 void can_led_event(struct net_device *netdev, enum can_led_event event)
  23 {
  24         struct can_priv *priv = netdev_priv(netdev);
  25 
  26         switch (event) {
  27         case CAN_LED_EVENT_OPEN:
  28                 led_trigger_event(priv->tx_led_trig, LED_FULL);
  29                 led_trigger_event(priv->rx_led_trig, LED_FULL);
  30                 led_trigger_event(priv->rxtx_led_trig, LED_FULL);
  31                 break;
  32         case CAN_LED_EVENT_STOP:
  33                 led_trigger_event(priv->tx_led_trig, LED_OFF);
  34                 led_trigger_event(priv->rx_led_trig, LED_OFF);
  35                 led_trigger_event(priv->rxtx_led_trig, LED_OFF);
  36                 break;
  37         case CAN_LED_EVENT_TX:
  38                 if (led_delay) {
  39                         led_trigger_blink_oneshot(priv->tx_led_trig,
  40                                                   &led_delay, &led_delay, 1);
  41                         led_trigger_blink_oneshot(priv->rxtx_led_trig,
  42                                                   &led_delay, &led_delay, 1);
  43                 }
  44                 break;
  45         case CAN_LED_EVENT_RX:
  46                 if (led_delay) {
  47                         led_trigger_blink_oneshot(priv->rx_led_trig,
  48                                                   &led_delay, &led_delay, 1);
  49                         led_trigger_blink_oneshot(priv->rxtx_led_trig,
  50                                                   &led_delay, &led_delay, 1);
  51                 }
  52                 break;
  53         }
  54 }
  55 EXPORT_SYMBOL_GPL(can_led_event);
  56 
  57 static void can_led_release(struct device *gendev, void *res)
  58 {
  59         struct can_priv *priv = netdev_priv(to_net_dev(gendev));
  60 
  61         led_trigger_unregister_simple(priv->tx_led_trig);
  62         led_trigger_unregister_simple(priv->rx_led_trig);
  63         led_trigger_unregister_simple(priv->rxtx_led_trig);
  64 }
  65 
  66 /* Register CAN LED triggers for a CAN device
  67  *
  68  * This is normally called from a driver's probe function
  69  */
  70 void devm_can_led_init(struct net_device *netdev)
  71 {
  72         struct can_priv *priv = netdev_priv(netdev);
  73         void *res;
  74 
  75         res = devres_alloc(can_led_release, 0, GFP_KERNEL);
  76         if (!res) {
  77                 netdev_err(netdev, "cannot register LED triggers\n");
  78                 return;
  79         }
  80 
  81         snprintf(priv->tx_led_trig_name, sizeof(priv->tx_led_trig_name),
  82                  "%s-tx", netdev->name);
  83         snprintf(priv->rx_led_trig_name, sizeof(priv->rx_led_trig_name),
  84                  "%s-rx", netdev->name);
  85         snprintf(priv->rxtx_led_trig_name, sizeof(priv->rxtx_led_trig_name),
  86                  "%s-rxtx", netdev->name);
  87 
  88         led_trigger_register_simple(priv->tx_led_trig_name,
  89                                     &priv->tx_led_trig);
  90         led_trigger_register_simple(priv->rx_led_trig_name,
  91                                     &priv->rx_led_trig);
  92         led_trigger_register_simple(priv->rxtx_led_trig_name,
  93                                     &priv->rxtx_led_trig);
  94 
  95         devres_add(&netdev->dev, res);
  96 }
  97 EXPORT_SYMBOL_GPL(devm_can_led_init);
  98 
  99 /* NETDEV rename notifier to rename the associated led triggers too */
 100 static int can_led_notifier(struct notifier_block *nb, unsigned long msg,
 101                             void *ptr)
 102 {
 103         struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
 104         struct can_priv *priv = safe_candev_priv(netdev);
 105         char name[CAN_LED_NAME_SZ];
 106 
 107         if (!priv)
 108                 return NOTIFY_DONE;
 109 
 110         if (!priv->tx_led_trig || !priv->rx_led_trig || !priv->rxtx_led_trig)
 111                 return NOTIFY_DONE;
 112 
 113         if (msg == NETDEV_CHANGENAME) {
 114                 snprintf(name, sizeof(name), "%s-tx", netdev->name);
 115                 led_trigger_rename_static(name, priv->tx_led_trig);
 116 
 117                 snprintf(name, sizeof(name), "%s-rx", netdev->name);
 118                 led_trigger_rename_static(name, priv->rx_led_trig);
 119 
 120                 snprintf(name, sizeof(name), "%s-rxtx", netdev->name);
 121                 led_trigger_rename_static(name, priv->rxtx_led_trig);
 122         }
 123 
 124         return NOTIFY_DONE;
 125 }
 126 
 127 /* notifier block for netdevice event */
 128 static struct notifier_block can_netdev_notifier __read_mostly = {
 129         .notifier_call = can_led_notifier,
 130 };
 131 
 132 int __init can_led_notifier_init(void)
 133 {
 134         return register_netdevice_notifier(&can_netdev_notifier);
 135 }
 136 
 137 void __exit can_led_notifier_exit(void)
 138 {
 139         unregister_netdevice_notifier(&can_netdev_notifier);
 140 }