[linux-2.6-block.git] / drivers / net / can / led.c

/*
 * Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
 * Copyright 2012, Kurt Van Dijck <kurt.van.dijck@eia.be>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/netdevice.h>
#include <linux/can/dev.h>

#include <linux/can/led.h>

static unsigned long led_delay = 50;
module_param(led_delay, ulong, 0644);
MODULE_PARM_DESC(led_delay,
		"blink delay time for activity leds (msecs, default: 50).");

/* Trigger a LED event in response to a CAN device event */
void can_led_event(struct net_device *netdev, enum can_led_event event)
{
	struct can_priv *priv = netdev_priv(netdev);

	switch (event) {
	case CAN_LED_EVENT_OPEN:
		led_trigger_event(priv->tx_led_trig, LED_FULL);
		led_trigger_event(priv->rx_led_trig, LED_FULL);
		led_trigger_event(priv->rxtx_led_trig, LED_FULL);
		break;
	case CAN_LED_EVENT_STOP:
		led_trigger_event(priv->tx_led_trig, LED_OFF);
		led_trigger_event(priv->rx_led_trig, LED_OFF);
		led_trigger_event(priv->rxtx_led_trig, LED_OFF);
		break;
	case CAN_LED_EVENT_TX:
		if (led_delay) {
			led_trigger_blink_oneshot(priv->tx_led_trig,
						  &led_delay, &led_delay, 1);
			led_trigger_blink_oneshot(priv->rxtx_led_trig,
						  &led_delay, &led_delay, 1);
		}
		break;
	case CAN_LED_EVENT_RX:
		if (led_delay) {
			led_trigger_blink_oneshot(priv->rx_led_trig,
						  &led_delay, &led_delay, 1);
			led_trigger_blink_oneshot(priv->rxtx_led_trig,
						  &led_delay, &led_delay, 1);
		}
		break;
	}
}
EXPORT_SYMBOL_GPL(can_led_event);

static void can_led_release(struct device *gendev, void *res)
{
	struct can_priv *priv = netdev_priv(to_net_dev(gendev));

	led_trigger_unregister_simple(priv->tx_led_trig);
	led_trigger_unregister_simple(priv->rx_led_trig);
	led_trigger_unregister_simple(priv->rxtx_led_trig);
}

/* Register CAN LED triggers for a CAN device
 *
 * This is normally called from a driver's probe function
 */
void devm_can_led_init(struct net_device *netdev)
{
	struct can_priv *priv = netdev_priv(netdev);
	void *res;

	res = devres_alloc(can_led_release, 0, GFP_KERNEL);
	if (!res) {
		netdev_err(netdev, "cannot register LED triggers\n");
		return;
	}

	snprintf(priv->tx_led_trig_name, sizeof(priv->tx_led_trig_name),
		 "%s-tx", netdev->name);
	snprintf(priv->rx_led_trig_name, sizeof(priv->rx_led_trig_name),
		 "%s-rx", netdev->name);
	snprintf(priv->rxtx_led_trig_name, sizeof(priv->rxtx_led_trig_name),
		 "%s-rxtx", netdev->name);

	led_trigger_register_simple(priv->tx_led_trig_name,
				    &priv->tx_led_trig);
	led_trigger_register_simple(priv->rx_led_trig_name,
				    &priv->rx_led_trig);
	led_trigger_register_simple(priv->rxtx_led_trig_name,
				    &priv->rxtx_led_trig);

	devres_add(&netdev->dev, res);
}
EXPORT_SYMBOL_GPL(devm_can_led_init);

/* NETDEV rename notifier to rename the associated led triggers too */
static int can_led_notifier(struct notifier_block *nb, unsigned long msg,
			    void *ptr)
{
	struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
	struct can_priv *priv = safe_candev_priv(netdev);
	char name[CAN_LED_NAME_SZ];

	if (!priv)
		return NOTIFY_DONE;

	if (!priv->tx_led_trig || !priv->rx_led_trig || !priv->rxtx_led_trig)
		return NOTIFY_DONE;

	if (msg == NETDEV_CHANGENAME) {
		snprintf(name, sizeof(name), "%s-tx", netdev->name);
		led_trigger_rename_static(name, priv->tx_led_trig);

		snprintf(name, sizeof(name), "%s-rx", netdev->name);
		led_trigger_rename_static(name, priv->rx_led_trig);

		snprintf(name, sizeof(name), "%s-rxtx", netdev->name);
		led_trigger_rename_static(name, priv->rxtx_led_trig);
	}

	return NOTIFY_DONE;
}

/* notifier block for netdevice event */
static struct notifier_block can_netdev_notifier __read_mostly = {
	.notifier_call = can_led_notifier,
};

int __init can_led_notifier_init(void)
{
	return register_netdevice_notifier(&can_netdev_notifier);
}

void __exit can_led_notifier_exit(void)
{
	unregister_netdevice_notifier(&can_netdev_notifier);
}
Commit	Line	Data
996a953d FB	1	/*
996a953d FB	2	* Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
a1ef7bd9	3	* Copyright 2012, Kurt Van Dijck <kurt.van.dijck@eia.be>
996a953d FB	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);
c54eb70e	33	led_trigger_event(priv->rxtx_led_trig, LED_FULL);
996a953d FB	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);
c54eb70e	38	led_trigger_event(priv->rxtx_led_trig, LED_OFF);
996a953d FB	39	break;
996a953d FB	40	case CAN_LED_EVENT_TX:
c54eb70e	41	if (led_delay) {
996a953d FB	42	led_trigger_blink_oneshot(priv->tx_led_trig,
996a953d FB	43	&led_delay, &led_delay, 1);
c54eb70e YY	44	led_trigger_blink_oneshot(priv->rxtx_led_trig,
	45	&led_delay, &led_delay, 1);
	46	}
996a953d FB	47	break;
996a953d FB	48	case CAN_LED_EVENT_RX:
c54eb70e	49	if (led_delay) {
996a953d FB	50	led_trigger_blink_oneshot(priv->rx_led_trig,
996a953d FB	51	&led_delay, &led_delay, 1);
c54eb70e YY	52	led_trigger_blink_oneshot(priv->rxtx_led_trig,
	53	&led_delay, &led_delay, 1);
	54	}
996a953d FB	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);
c54eb70e	66	led_trigger_unregister_simple(priv->rxtx_led_trig);
996a953d FB	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);
c54eb70e YY	88	snprintf(priv->rxtx_led_trig_name, sizeof(priv->rxtx_led_trig_name),
c54eb70e YY	89	"%s-rxtx", netdev->name);
996a953d FB	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);
c54eb70e YY	95	led_trigger_register_simple(priv->rxtx_led_trig_name,
c54eb70e YY	96	&priv->rxtx_led_trig);
996a953d FB	97
	98	devres_add(&netdev->dev, res);
	99	}
	100	EXPORT_SYMBOL_GPL(devm_can_led_init);
a1ef7bd9 KVD	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,
351638e7	104	void *ptr)
a1ef7bd9	105	{
351638e7	106	struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
a1ef7bd9 KVD	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
c54eb70e	113	if (!priv->tx_led_trig \|\| !priv->rx_led_trig \|\| !priv->rxtx_led_trig)
45fb4f8d OH	114	return NOTIFY_DONE;
45fb4f8d OH	115
a1ef7bd9 KVD	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);
c54eb70e YY	122
	123	snprintf(name, sizeof(name), "%s-rxtx", netdev->name);
	124	led_trigger_rename_static(name, priv->rxtx_led_trig);
a1ef7bd9 KVD	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	}