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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright 2006, Johannes Berg <johannes@sipsolutions.net>
 */

/* just for IFNAMSIZ */
#include <linux/if.h>
#include <linux/slab.h>
#include <linux/export.h>
#include "led.h"

void ieee80211_led_assoc(struct ieee80211_local *local, bool associated)
{
	if (!atomic_read(&local->assoc_led_active))
		return;
	if (associated)
		led_trigger_event(&local->assoc_led, LED_FULL);
	else
		led_trigger_event(&local->assoc_led, LED_OFF);
}

void ieee80211_led_radio(struct ieee80211_local *local, bool enabled)
{
	if (!atomic_read(&local->radio_led_active))
		return;
	if (enabled)
		led_trigger_event(&local->radio_led, LED_FULL);
	else
		led_trigger_event(&local->radio_led, LED_OFF);
}

void ieee80211_alloc_led_names(struct ieee80211_local *local)
{
	local->rx_led.name = kasprintf(GFP_KERNEL, "%srx",
				       wiphy_name(local->hw.wiphy));
	local->tx_led.name = kasprintf(GFP_KERNEL, "%stx",
				       wiphy_name(local->hw.wiphy));
	local->assoc_led.name = kasprintf(GFP_KERNEL, "%sassoc",
					  wiphy_name(local->hw.wiphy));
	local->radio_led.name = kasprintf(GFP_KERNEL, "%sradio",
					  wiphy_name(local->hw.wiphy));
}

void ieee80211_free_led_names(struct ieee80211_local *local)
{
	kfree(local->rx_led.name);
	kfree(local->tx_led.name);
	kfree(local->assoc_led.name);
	kfree(local->radio_led.name);
}

static int ieee80211_tx_led_activate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     tx_led);

	atomic_inc(&local->tx_led_active);

	return 0;
}

static void ieee80211_tx_led_deactivate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     tx_led);

	atomic_dec(&local->tx_led_active);
}

static int ieee80211_rx_led_activate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     rx_led);

	atomic_inc(&local->rx_led_active);

	return 0;
}

static void ieee80211_rx_led_deactivate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     rx_led);

	atomic_dec(&local->rx_led_active);
}

static int ieee80211_assoc_led_activate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     assoc_led);

	atomic_inc(&local->assoc_led_active);

	return 0;
}

static void ieee80211_assoc_led_deactivate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     assoc_led);

	atomic_dec(&local->assoc_led_active);
}

static int ieee80211_radio_led_activate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     radio_led);

	atomic_inc(&local->radio_led_active);

	return 0;
}

static void ieee80211_radio_led_deactivate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     radio_led);

	atomic_dec(&local->radio_led_active);
}

static int ieee80211_tpt_led_activate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     tpt_led);

	atomic_inc(&local->tpt_led_active);

	return 0;
}

static void ieee80211_tpt_led_deactivate(struct led_classdev *led_cdev)
{
	struct ieee80211_local *local = container_of(led_cdev->trigger,
						     struct ieee80211_local,
						     tpt_led);

	atomic_dec(&local->tpt_led_active);
}

void ieee80211_led_init(struct ieee80211_local *local)
{
	atomic_set(&local->rx_led_active, 0);
	local->rx_led.activate = ieee80211_rx_led_activate;
	local->rx_led.deactivate = ieee80211_rx_led_deactivate;
	if (local->rx_led.name && led_trigger_register(&local->rx_led)) {
		kfree(local->rx_led.name);
		local->rx_led.name = NULL;
	}

	atomic_set(&local->tx_led_active, 0);
	local->tx_led.activate = ieee80211_tx_led_activate;
	local->tx_led.deactivate = ieee80211_tx_led_deactivate;
	if (local->tx_led.name && led_trigger_register(&local->tx_led)) {
		kfree(local->tx_led.name);
		local->tx_led.name = NULL;
	}

	atomic_set(&local->assoc_led_active, 0);
	local->assoc_led.activate = ieee80211_assoc_led_activate;
	local->assoc_led.deactivate = ieee80211_assoc_led_deactivate;
	if (local->assoc_led.name && led_trigger_register(&local->assoc_led)) {
		kfree(local->assoc_led.name);
		local->assoc_led.name = NULL;
	}

	atomic_set(&local->radio_led_active, 0);
	local->radio_led.activate = ieee80211_radio_led_activate;
	local->radio_led.deactivate = ieee80211_radio_led_deactivate;
	if (local->radio_led.name && led_trigger_register(&local->radio_led)) {
		kfree(local->radio_led.name);
		local->radio_led.name = NULL;
	}

	atomic_set(&local->tpt_led_active, 0);
	if (local->tpt_led_trigger) {
		local->tpt_led.activate = ieee80211_tpt_led_activate;
		local->tpt_led.deactivate = ieee80211_tpt_led_deactivate;
		if (led_trigger_register(&local->tpt_led)) {
			kfree(local->tpt_led_trigger);
			local->tpt_led_trigger = NULL;
		}
	}
}

void ieee80211_led_exit(struct ieee80211_local *local)
{
	if (local->radio_led.name)
		led_trigger_unregister(&local->radio_led);
	if (local->assoc_led.name)
		led_trigger_unregister(&local->assoc_led);
	if (local->tx_led.name)
		led_trigger_unregister(&local->tx_led);
	if (local->rx_led.name)
		led_trigger_unregister(&local->rx_led);

	if (local->tpt_led_trigger) {
		led_trigger_unregister(&local->tpt_led);
		kfree(local->tpt_led_trigger);
	}
}

const char *__ieee80211_get_radio_led_name(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

	return local->radio_led.name;
}
EXPORT_SYMBOL(__ieee80211_get_radio_led_name);

const char *__ieee80211_get_assoc_led_name(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

	return local->assoc_led.name;
}
EXPORT_SYMBOL(__ieee80211_get_assoc_led_name);

const char *__ieee80211_get_tx_led_name(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

	return local->tx_led.name;
}
EXPORT_SYMBOL(__ieee80211_get_tx_led_name);

const char *__ieee80211_get_rx_led_name(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

	return local->rx_led.name;
}
EXPORT_SYMBOL(__ieee80211_get_rx_led_name);

static unsigned long tpt_trig_traffic(struct ieee80211_local *local,
				      struct tpt_led_trigger *tpt_trig)
{
	unsigned long traffic, delta;

	traffic = tpt_trig->tx_bytes + tpt_trig->rx_bytes;

	delta = traffic - tpt_trig->prev_traffic;
	tpt_trig->prev_traffic = traffic;
	return DIV_ROUND_UP(delta, 1024 / 8);
}

static void tpt_trig_timer(struct timer_list *t)
{
	struct tpt_led_trigger *tpt_trig = from_timer(tpt_trig, t, timer);
	struct ieee80211_local *local = tpt_trig->local;
	struct led_classdev *led_cdev;
	unsigned long on, off, tpt;
	int i;

	if (!tpt_trig->running)
		return;

	mod_timer(&tpt_trig->timer, round_jiffies(jiffies + HZ));

	tpt = tpt_trig_traffic(local, tpt_trig);

	/* default to just solid on */
	on = 1;
	off = 0;

	for (i = tpt_trig->blink_table_len - 1; i >= 0; i--) {
		if (tpt_trig->blink_table[i].throughput < 0 ||
		    tpt > tpt_trig->blink_table[i].throughput) {
			off = tpt_trig->blink_table[i].blink_time / 2;
			on = tpt_trig->blink_table[i].blink_time - off;
			break;
		}
	}

	read_lock(&local->tpt_led.leddev_list_lock);
	list_for_each_entry(led_cdev, &local->tpt_led.led_cdevs, trig_list)
		led_blink_set(led_cdev, &on, &off);
	read_unlock(&local->tpt_led.leddev_list_lock);
}

const char *
__ieee80211_create_tpt_led_trigger(struct ieee80211_hw *hw,
				   unsigned int flags,
				   const struct ieee80211_tpt_blink *blink_table,
				   unsigned int blink_table_len)
{
	struct ieee80211_local *local = hw_to_local(hw);
	struct tpt_led_trigger *tpt_trig;

	if (WARN_ON(local->tpt_led_trigger))
		return NULL;

	tpt_trig = kzalloc(sizeof(struct tpt_led_trigger), GFP_KERNEL);
	if (!tpt_trig)
		return NULL;

	snprintf(tpt_trig->name, sizeof(tpt_trig->name),
		 "%stpt", wiphy_name(local->hw.wiphy));

	local->tpt_led.name = tpt_trig->name;

	tpt_trig->blink_table = blink_table;
	tpt_trig->blink_table_len = blink_table_len;
	tpt_trig->want = flags;
	tpt_trig->local = local;

	timer_setup(&tpt_trig->timer, tpt_trig_timer, 0);

	local->tpt_led_trigger = tpt_trig;

	return tpt_trig->name;
}
EXPORT_SYMBOL(__ieee80211_create_tpt_led_trigger);

static void ieee80211_start_tpt_led_trig(struct ieee80211_local *local)
{
	struct tpt_led_trigger *tpt_trig = local->tpt_led_trigger;

	if (tpt_trig->running)
		return;

	/* reset traffic */
	tpt_trig_traffic(local, tpt_trig);
	tpt_trig->running = true;

	tpt_trig_timer(&tpt_trig->timer);
	mod_timer(&tpt_trig->timer, round_jiffies(jiffies + HZ));
}

static void ieee80211_stop_tpt_led_trig(struct ieee80211_local *local)
{
	struct tpt_led_trigger *tpt_trig = local->tpt_led_trigger;
	struct led_classdev *led_cdev;

	if (!tpt_trig->running)
		return;

	tpt_trig->running = false;
	del_timer_sync(&tpt_trig->timer);

	read_lock(&local->tpt_led.leddev_list_lock);
	list_for_each_entry(led_cdev, &local->tpt_led.led_cdevs, trig_list)
		led_set_brightness(led_cdev, LED_OFF);
	read_unlock(&local->tpt_led.leddev_list_lock);
}

void ieee80211_mod_tpt_led_trig(struct ieee80211_local *local,
				unsigned int types_on, unsigned int types_off)
{
	struct tpt_led_trigger *tpt_trig = local->tpt_led_trigger;
	bool allowed;

	WARN_ON(types_on & types_off);

	if (!tpt_trig)
		return;

	tpt_trig->active &= ~types_off;
	tpt_trig->active |= types_on;

	/*
	 * Regardless of wanted state, we shouldn't blink when
	 * the radio is disabled -- this can happen due to some
	 * code ordering issues with __ieee80211_recalc_idle()
	 * being called before the radio is started.
	 */
	allowed = tpt_trig->active & IEEE80211_TPT_LEDTRIG_FL_RADIO;

	if (!allowed || !(tpt_trig->active & tpt_trig->want))
		ieee80211_stop_tpt_led_trig(local);
	else
		ieee80211_start_tpt_led_trig(local);
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
f0706e82 JB	2	/*
f0706e82 JB	3	* Copyright 2006, Johannes Berg <johannes@sipsolutions.net>
f0706e82 JB	4	*/
	5
	6	/* just for IFNAMSIZ */
	7	#include <linux/if.h>
5a0e3ad6	8	#include <linux/slab.h>
bc3b2d7f	9	#include <linux/export.h>
2c8dccc7	10	#include "led.h"
f0706e82	11
47f0c502 MB	12	void ieee80211_led_assoc(struct ieee80211_local *local, bool associated)
47f0c502 MB	13	{
8d5c2585	14	if (!atomic_read(&local->assoc_led_active))
47f0c502 MB	15	return;
47f0c502 MB	16	if (associated)
8d5c2585	17	led_trigger_event(&local->assoc_led, LED_FULL);
47f0c502	18	else
8d5c2585	19	led_trigger_event(&local->assoc_led, LED_OFF);
47f0c502 MB	20	}
47f0c502 MB	21
cdcb006f ID	22	void ieee80211_led_radio(struct ieee80211_local *local, bool enabled)
cdcb006f ID	23	{
8d5c2585	24	if (!atomic_read(&local->radio_led_active))
cdcb006f ID	25	return;
cdcb006f ID	26	if (enabled)
8d5c2585	27	led_trigger_event(&local->radio_led, LED_FULL);
cdcb006f	28	else
8d5c2585 JB	29	led_trigger_event(&local->radio_led, LED_OFF);
	30	}
	31
	32	void ieee80211_alloc_led_names(struct ieee80211_local *local)
	33	{
	34	local->rx_led.name = kasprintf(GFP_KERNEL, "%srx",
	35	wiphy_name(local->hw.wiphy));
	36	local->tx_led.name = kasprintf(GFP_KERNEL, "%stx",
	37	wiphy_name(local->hw.wiphy));
	38	local->assoc_led.name = kasprintf(GFP_KERNEL, "%sassoc",
	39	wiphy_name(local->hw.wiphy));
	40	local->radio_led.name = kasprintf(GFP_KERNEL, "%sradio",
	41	wiphy_name(local->hw.wiphy));
	42	}
	43
	44	void ieee80211_free_led_names(struct ieee80211_local *local)
	45	{
	46	kfree(local->rx_led.name);
	47	kfree(local->tx_led.name);
	48	kfree(local->assoc_led.name);
	49	kfree(local->radio_led.name);
	50	}
	51
2282e125	52	static int ieee80211_tx_led_activate(struct led_classdev *led_cdev)
8d5c2585 JB	53	{
	54	struct ieee80211_local *local = container_of(led_cdev->trigger,
	55	struct ieee80211_local,
	56	tx_led);
	57
	58	atomic_inc(&local->tx_led_active);
2282e125 UKK	59
2282e125 UKK	60	return 0;
8d5c2585 JB	61	}
	62
	63	static void ieee80211_tx_led_deactivate(struct led_classdev *led_cdev)
	64	{
	65	struct ieee80211_local *local = container_of(led_cdev->trigger,
	66	struct ieee80211_local,
	67	tx_led);
	68
	69	atomic_dec(&local->tx_led_active);
	70	}
	71
2282e125	72	static int ieee80211_rx_led_activate(struct led_classdev *led_cdev)
8d5c2585 JB	73	{
	74	struct ieee80211_local *local = container_of(led_cdev->trigger,
	75	struct ieee80211_local,
	76	rx_led);
	77
	78	atomic_inc(&local->rx_led_active);
2282e125 UKK	79
2282e125 UKK	80	return 0;
8d5c2585 JB	81	}
	82
	83	static void ieee80211_rx_led_deactivate(struct led_classdev *led_cdev)
	84	{
	85	struct ieee80211_local *local = container_of(led_cdev->trigger,
	86	struct ieee80211_local,
	87	rx_led);
	88
	89	atomic_dec(&local->rx_led_active);
	90	}
	91
2282e125	92	static int ieee80211_assoc_led_activate(struct led_classdev *led_cdev)
8d5c2585 JB	93	{
	94	struct ieee80211_local *local = container_of(led_cdev->trigger,
	95	struct ieee80211_local,
	96	assoc_led);
	97
	98	atomic_inc(&local->assoc_led_active);
2282e125 UKK	99
2282e125 UKK	100	return 0;
8d5c2585 JB	101	}
	102
	103	static void ieee80211_assoc_led_deactivate(struct led_classdev *led_cdev)
	104	{
	105	struct ieee80211_local *local = container_of(led_cdev->trigger,
	106	struct ieee80211_local,
	107	assoc_led);
	108
	109	atomic_dec(&local->assoc_led_active);
	110	}
	111
2282e125	112	static int ieee80211_radio_led_activate(struct led_classdev *led_cdev)
8d5c2585 JB	113	{
	114	struct ieee80211_local *local = container_of(led_cdev->trigger,
	115	struct ieee80211_local,
	116	radio_led);
	117
	118	atomic_inc(&local->radio_led_active);
2282e125 UKK	119
2282e125 UKK	120	return 0;
8d5c2585 JB	121	}
	122
	123	static void ieee80211_radio_led_deactivate(struct led_classdev *led_cdev)
	124	{
	125	struct ieee80211_local *local = container_of(led_cdev->trigger,
	126	struct ieee80211_local,
	127	radio_led);
	128
	129	atomic_dec(&local->radio_led_active);
	130	}
	131
2282e125	132	static int ieee80211_tpt_led_activate(struct led_classdev *led_cdev)
8d5c2585 JB	133	{
	134	struct ieee80211_local *local = container_of(led_cdev->trigger,
	135	struct ieee80211_local,
	136	tpt_led);
	137
	138	atomic_inc(&local->tpt_led_active);
2282e125 UKK	139
2282e125 UKK	140	return 0;
cdcb006f ID	141	}
cdcb006f ID	142
8d5c2585	143	static void ieee80211_tpt_led_deactivate(struct led_classdev *led_cdev)
fe67c913	144	{
8d5c2585 JB	145	struct ieee80211_local *local = container_of(led_cdev->trigger,
	146	struct ieee80211_local,
	147	tpt_led);
	148
	149	atomic_dec(&local->tpt_led_active);
fe67c913 JB	150	}
fe67c913 JB	151
f0706e82 JB	152	void ieee80211_led_init(struct ieee80211_local *local)
f0706e82 JB	153	{
8d5c2585 JB	154	atomic_set(&local->rx_led_active, 0);
	155	local->rx_led.activate = ieee80211_rx_led_activate;
	156	local->rx_led.deactivate = ieee80211_rx_led_deactivate;
	157	if (local->rx_led.name && led_trigger_register(&local->rx_led)) {
	158	kfree(local->rx_led.name);
	159	local->rx_led.name = NULL;
f0706e82 JB	160	}
f0706e82 JB	161
8d5c2585 JB	162	atomic_set(&local->tx_led_active, 0);
	163	local->tx_led.activate = ieee80211_tx_led_activate;
	164	local->tx_led.deactivate = ieee80211_tx_led_deactivate;
	165	if (local->tx_led.name && led_trigger_register(&local->tx_led)) {
	166	kfree(local->tx_led.name);
	167	local->tx_led.name = NULL;
47f0c502 MB	168	}
47f0c502 MB	169
8d5c2585 JB	170	atomic_set(&local->assoc_led_active, 0);
	171	local->assoc_led.activate = ieee80211_assoc_led_activate;
	172	local->assoc_led.deactivate = ieee80211_assoc_led_deactivate;
	173	if (local->assoc_led.name && led_trigger_register(&local->assoc_led)) {
	174	kfree(local->assoc_led.name);
	175	local->assoc_led.name = NULL;
f0706e82	176	}
cdcb006f	177
8d5c2585 JB	178	atomic_set(&local->radio_led_active, 0);
	179	local->radio_led.activate = ieee80211_radio_led_activate;
	180	local->radio_led.deactivate = ieee80211_radio_led_deactivate;
	181	if (local->radio_led.name && led_trigger_register(&local->radio_led)) {
	182	kfree(local->radio_led.name);
	183	local->radio_led.name = NULL;
cdcb006f	184	}
e1e54068	185
8d5c2585	186	atomic_set(&local->tpt_led_active, 0);
e1e54068	187	if (local->tpt_led_trigger) {
8d5c2585 JB	188	local->tpt_led.activate = ieee80211_tpt_led_activate;
	189	local->tpt_led.deactivate = ieee80211_tpt_led_deactivate;
	190	if (led_trigger_register(&local->tpt_led)) {
e1e54068 JB	191	kfree(local->tpt_led_trigger);
	192	local->tpt_led_trigger = NULL;
	193	}
	194	}
f0706e82 JB	195	}
	196
	197	void ieee80211_led_exit(struct ieee80211_local *local)
	198	{
8d5c2585 JB	199	if (local->radio_led.name)
	200	led_trigger_unregister(&local->radio_led);
	201	if (local->assoc_led.name)
	202	led_trigger_unregister(&local->assoc_led);
	203	if (local->tx_led.name)
	204	led_trigger_unregister(&local->tx_led);
	205	if (local->rx_led.name)
	206	led_trigger_unregister(&local->rx_led);
e1e54068 JB	207
e1e54068 JB	208	if (local->tpt_led_trigger) {
8d5c2585	209	led_trigger_unregister(&local->tpt_led);
e1e54068 JB	210	kfree(local->tpt_led_trigger);
e1e54068 JB	211	}
f0706e82 JB	212	}
f0706e82 JB	213
f5c4ae07	214	const char __ieee80211_get_radio_led_name(struct ieee80211_hw hw)
cdcb006f ID	215	{
	216	struct ieee80211_local *local = hw_to_local(hw);
	217
8d5c2585	218	return local->radio_led.name;
cdcb006f ID	219	}
	220	EXPORT_SYMBOL(__ieee80211_get_radio_led_name);
	221
f5c4ae07	222	const char __ieee80211_get_assoc_led_name(struct ieee80211_hw hw)
47f0c502 MB	223	{
	224	struct ieee80211_local *local = hw_to_local(hw);
	225
8d5c2585	226	return local->assoc_led.name;
47f0c502 MB	227	}
	228	EXPORT_SYMBOL(__ieee80211_get_assoc_led_name);
	229
f5c4ae07	230	const char __ieee80211_get_tx_led_name(struct ieee80211_hw hw)
f0706e82 JB	231	{
	232	struct ieee80211_local *local = hw_to_local(hw);
	233
8d5c2585	234	return local->tx_led.name;
f0706e82 JB	235	}
	236	EXPORT_SYMBOL(__ieee80211_get_tx_led_name);
	237
f5c4ae07	238	const char __ieee80211_get_rx_led_name(struct ieee80211_hw hw)
f0706e82 JB	239	{
	240	struct ieee80211_local *local = hw_to_local(hw);
	241
8d5c2585	242	return local->rx_led.name;
f0706e82 JB	243	}
f0706e82 JB	244	EXPORT_SYMBOL(__ieee80211_get_rx_led_name);
e1e54068 JB	245
	246	static unsigned long tpt_trig_traffic(struct ieee80211_local *local,
	247	struct tpt_led_trigger *tpt_trig)
	248	{
	249	unsigned long traffic, delta;
	250
	251	traffic = tpt_trig->tx_bytes + tpt_trig->rx_bytes;
	252
	253	delta = traffic - tpt_trig->prev_traffic;
	254	tpt_trig->prev_traffic = traffic;
	255	return DIV_ROUND_UP(delta, 1024 / 8);
	256	}
	257
34f11cd3	258	static void tpt_trig_timer(struct timer_list *t)
e1e54068	259	{
34f11cd3 KC	260	struct tpt_led_trigger *tpt_trig = from_timer(tpt_trig, t, timer);
34f11cd3 KC	261	struct ieee80211_local *local = tpt_trig->local;
e1e54068 JB	262	struct led_classdev *led_cdev;
	263	unsigned long on, off, tpt;
	264	int i;
	265
	266	if (!tpt_trig->running)
	267	return;
	268
	269	mod_timer(&tpt_trig->timer, round_jiffies(jiffies + HZ));
	270
	271	tpt = tpt_trig_traffic(local, tpt_trig);
	272
	273	/* default to just solid on */
	274	on = 1;
	275	off = 0;
	276
	277	for (i = tpt_trig->blink_table_len - 1; i >= 0; i--) {
	278	if (tpt_trig->blink_table[i].throughput < 0 \|\|
	279	tpt > tpt_trig->blink_table[i].throughput) {
	280	off = tpt_trig->blink_table[i].blink_time / 2;
	281	on = tpt_trig->blink_table[i].blink_time - off;
	282	break;
	283	}
	284	}
	285
658358ce JB	286	read_lock(&local->tpt_led.leddev_list_lock);
658358ce JB	287	list_for_each_entry(led_cdev, &local->tpt_led.led_cdevs, trig_list)
e1e54068	288	led_blink_set(led_cdev, &on, &off);
658358ce	289	read_unlock(&local->tpt_led.leddev_list_lock);
e1e54068 JB	290	}
e1e54068 JB	291
f5c4ae07 JB	292	const char *
	293	__ieee80211_create_tpt_led_trigger(struct ieee80211_hw *hw,
	294	unsigned int flags,
	295	const struct ieee80211_tpt_blink *blink_table,
	296	unsigned int blink_table_len)
e1e54068 JB	297	{
	298	struct ieee80211_local *local = hw_to_local(hw);
	299	struct tpt_led_trigger *tpt_trig;
	300
	301	if (WARN_ON(local->tpt_led_trigger))
	302	return NULL;
	303
	304	tpt_trig = kzalloc(sizeof(struct tpt_led_trigger), GFP_KERNEL);
	305	if (!tpt_trig)
	306	return NULL;
	307
	308	snprintf(tpt_trig->name, sizeof(tpt_trig->name),
	309	"%stpt", wiphy_name(local->hw.wiphy));
	310
8d5c2585	311	local->tpt_led.name = tpt_trig->name;
e1e54068 JB	312
	313	tpt_trig->blink_table = blink_table;
	314	tpt_trig->blink_table_len = blink_table_len;
67408c8c	315	tpt_trig->want = flags;
34f11cd3	316	tpt_trig->local = local;
e1e54068	317
34f11cd3	318	timer_setup(&tpt_trig->timer, tpt_trig_timer, 0);
e1e54068 JB	319
	320	local->tpt_led_trigger = tpt_trig;
	321
	322	return tpt_trig->name;
	323	}
	324	EXPORT_SYMBOL(__ieee80211_create_tpt_led_trigger);
	325
67408c8c	326	static void ieee80211_start_tpt_led_trig(struct ieee80211_local *local)
e1e54068 JB	327	{
	328	struct tpt_led_trigger *tpt_trig = local->tpt_led_trigger;
	329
67408c8c	330	if (tpt_trig->running)
e1e54068 JB	331	return;
	332
	333	/* reset traffic */
	334	tpt_trig_traffic(local, tpt_trig);
	335	tpt_trig->running = true;
	336
34f11cd3	337	tpt_trig_timer(&tpt_trig->timer);
e1e54068 JB	338	mod_timer(&tpt_trig->timer, round_jiffies(jiffies + HZ));
	339	}
	340
67408c8c	341	static void ieee80211_stop_tpt_led_trig(struct ieee80211_local *local)
e1e54068 JB	342	{
	343	struct tpt_led_trigger *tpt_trig = local->tpt_led_trigger;
	344	struct led_classdev *led_cdev;
	345
67408c8c	346	if (!tpt_trig->running)
e1e54068 JB	347	return;
	348
	349	tpt_trig->running = false;
	350	del_timer_sync(&tpt_trig->timer);
	351
658358ce JB	352	read_lock(&local->tpt_led.leddev_list_lock);
658358ce JB	353	list_for_each_entry(led_cdev, &local->tpt_led.led_cdevs, trig_list)
19cd67e2	354	led_set_brightness(led_cdev, LED_OFF);
658358ce	355	read_unlock(&local->tpt_led.leddev_list_lock);
e1e54068	356	}
67408c8c JB	357
	358	void ieee80211_mod_tpt_led_trig(struct ieee80211_local *local,
	359	unsigned int types_on, unsigned int types_off)
	360	{
	361	struct tpt_led_trigger *tpt_trig = local->tpt_led_trigger;
	362	bool allowed;
	363
	364	WARN_ON(types_on & types_off);
	365
	366	if (!tpt_trig)
	367	return;
	368
	369	tpt_trig->active &= ~types_off;
	370	tpt_trig->active \|= types_on;
	371
	372	/*
	373	* Regardless of wanted state, we shouldn't blink when
	374	* the radio is disabled -- this can happen due to some
	375	* code ordering issues with __ieee80211_recalc_idle()
	376	* being called before the radio is started.
	377	*/
	378	allowed = tpt_trig->active & IEEE80211_TPT_LEDTRIG_FL_RADIO;
	379
	380	if (!allowed \|\| !(tpt_trig->active & tpt_trig->want))
	381	ieee80211_stop_tpt_led_trig(local);
	382	else
	383	ieee80211_start_tpt_led_trig(local);
	384	}