kernel/drivers/net/can/led.c

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