[linux-2.6-block.git] / drivers / net / wireless / rt2x00 / rt2x00leds.c

/*
	Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
	<http://rt2x00.serialmonkey.com>

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the
	Free Software Foundation, Inc.,
	59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*
	Module: rt2x00lib
	Abstract: rt2x00 led specific routines.
 */

#include <linux/kernel.h>
#include <linux/module.h>

#include "rt2x00.h"
#include "rt2x00lib.h"

void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, int rssi)
{
	struct rt2x00_led *led = &rt2x00dev->led_qual;
	unsigned int brightness;

	if ((led->type != LED_TYPE_QUALITY) || !(led->flags & LED_REGISTERED))
		return;

	/*
	 * Led handling requires a positive value for the rssi,
	 * to do that correctly we need to add the correction.
	 */
	rssi += rt2x00dev->rssi_offset;

	/*
	 * Get the rssi level, this is used to convert the rssi
	 * to a LED value inside the range LED_OFF - LED_FULL.
	 */
	if (rssi <= 30)
		rssi = 0;
	else if (rssi <= 39)
		rssi = 1;
	else if (rssi <= 49)
		rssi = 2;
	else if (rssi <= 53)
		rssi = 3;
	else if (rssi <= 63)
		rssi = 4;
	else
		rssi = 5;

	/*
	 * Note that we must _not_ send LED_OFF since the driver
	 * is going to calculate the value and might use it in a
	 * division.
	 */
	brightness = ((LED_FULL / 6) * rssi) + 1;
	if (brightness != led->led_dev.brightness) {
		led->led_dev.brightness_set(&led->led_dev, brightness);
		led->led_dev.brightness = brightness;
	}
}

static void rt2x00led_led_simple(struct rt2x00_led *led, bool enabled)
{
	unsigned int brightness = enabled ? LED_FULL : LED_OFF;

	if (!(led->flags & LED_REGISTERED))
		return;

	led->led_dev.brightness_set(&led->led_dev, brightness);
	led->led_dev.brightness = brightness;
}

void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled)
{
	if (rt2x00dev->led_qual.type == LED_TYPE_ACTIVITY)
		rt2x00led_led_simple(&rt2x00dev->led_qual, enabled);
}

void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled)
{
	if (rt2x00dev->led_assoc.type == LED_TYPE_ASSOC)
		rt2x00led_led_simple(&rt2x00dev->led_assoc, enabled);
}

void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled)
{
	if (rt2x00dev->led_radio.type == LED_TYPE_RADIO)
		rt2x00led_led_simple(&rt2x00dev->led_radio, enabled);
}

static int rt2x00leds_register_led(struct rt2x00_dev *rt2x00dev,
				   struct rt2x00_led *led,
				   const char *name)
{
	struct device *device = wiphy_dev(rt2x00dev->hw->wiphy);
	int retval;

	led->led_dev.name = name;
	led->led_dev.brightness = LED_OFF;

	retval = led_classdev_register(device, &led->led_dev);
	if (retval) {
		ERROR(rt2x00dev, "Failed to register led handler.\n");
		return retval;
	}

	led->flags |= LED_REGISTERED;

	return 0;
}

void rt2x00leds_register(struct rt2x00_dev *rt2x00dev)
{
	char dev_name[16];
	char name[32];
	int retval;
	unsigned long on_period;
	unsigned long off_period;

	snprintf(dev_name, sizeof(dev_name), "%s-%s",
		 rt2x00dev->ops->name, wiphy_name(rt2x00dev->hw->wiphy));

	if (rt2x00dev->led_radio.flags & LED_INITIALIZED) {
		snprintf(name, sizeof(name), "%s:radio", dev_name);

		retval = rt2x00leds_register_led(rt2x00dev,
						 &rt2x00dev->led_radio,
						 name);
		if (retval)
			goto exit_fail;
	}

	if (rt2x00dev->led_assoc.flags & LED_INITIALIZED) {
		snprintf(name, sizeof(name), "%s:assoc", dev_name);

		retval = rt2x00leds_register_led(rt2x00dev,
						 &rt2x00dev->led_assoc,
						 name);
		if (retval)
			goto exit_fail;
	}

	if (rt2x00dev->led_qual.flags & LED_INITIALIZED) {
		snprintf(name, sizeof(name), "%s:quality", dev_name);

		retval = rt2x00leds_register_led(rt2x00dev,
						 &rt2x00dev->led_qual,
						 name);
		if (retval)
			goto exit_fail;
	}

	/*
	 * Initialize blink time to default value:
	 * On period: 70ms
	 * Off period: 30ms
	 */
	if (rt2x00dev->led_radio.led_dev.blink_set) {
		on_period = 70;
		off_period = 30;
		rt2x00dev->led_radio.led_dev.blink_set(
		    &rt2x00dev->led_radio.led_dev, &on_period, &off_period);
	}

	return;

exit_fail:
	rt2x00leds_unregister(rt2x00dev);
}

static void rt2x00leds_unregister_led(struct rt2x00_led *led)
{
	led_classdev_unregister(&led->led_dev);

	/*
	 * This might look weird, but when we are unregistering while
	 * suspended the led is already off, and since we haven't
	 * fully resumed yet, access to the device might not be
	 * possible yet.
	 */
	if (!(led->led_dev.flags & LED_SUSPENDED))
		led->led_dev.brightness_set(&led->led_dev, LED_OFF);

	led->flags &= ~LED_REGISTERED;
}

void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev)
{
	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
		rt2x00leds_unregister_led(&rt2x00dev->led_qual);
	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
		rt2x00leds_unregister_led(&rt2x00dev->led_assoc);
	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
		rt2x00leds_unregister_led(&rt2x00dev->led_radio);
}

static inline void rt2x00leds_suspend_led(struct rt2x00_led *led)
{
	led_classdev_suspend(&led->led_dev);

	/* This shouldn't be needed, but just to be safe */
	led->led_dev.brightness_set(&led->led_dev, LED_OFF);
	led->led_dev.brightness = LED_OFF;
}

void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev)
{
	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
		rt2x00leds_suspend_led(&rt2x00dev->led_qual);
	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
		rt2x00leds_suspend_led(&rt2x00dev->led_assoc);
	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
		rt2x00leds_suspend_led(&rt2x00dev->led_radio);
}

static inline void rt2x00leds_resume_led(struct rt2x00_led *led)
{
	led_classdev_resume(&led->led_dev);

	/* Device might have enabled the LEDS during resume */
	led->led_dev.brightness_set(&led->led_dev, LED_OFF);
	led->led_dev.brightness = LED_OFF;
}

void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev)
{
	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
		rt2x00leds_resume_led(&rt2x00dev->led_radio);
	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
		rt2x00leds_resume_led(&rt2x00dev->led_assoc);
	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
		rt2x00leds_resume_led(&rt2x00dev->led_qual);
}
Commit	Line	Data
3b640f21 ID	1	/*
	2	Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
	3	<http://rt2x00.serialmonkey.com>
	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 as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the
	17	Free Software Foundation, Inc.,
	18	59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	19	*/
	20
	21	/*
	22	Module: rt2x00lib
	23	Abstract: rt2x00 led specific routines.
	24	*/
	25
	26	#include <linux/kernel.h>
	27	#include <linux/module.h>
	28
	29	#include "rt2x00.h"
	30	#include "rt2x00lib.h"
	31
	32	void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, int rssi)
	33	{
a2e1d52a ID	34	struct rt2x00_led *led = &rt2x00dev->led_qual;
	35	unsigned int brightness;
	36
	37	if ((led->type != LED_TYPE_QUALITY) \|\| !(led->flags & LED_REGISTERED))
3b640f21 ID	38	return;
	39
	40	/*
	41	* Led handling requires a positive value for the rssi,
	42	* to do that correctly we need to add the correction.
	43	*/
	44	rssi += rt2x00dev->rssi_offset;
	45
	46	/*
	47	* Get the rssi level, this is used to convert the rssi
	48	* to a LED value inside the range LED_OFF - LED_FULL.
	49	*/
	50	if (rssi <= 30)
	51	rssi = 0;
	52	else if (rssi <= 39)
	53	rssi = 1;
	54	else if (rssi <= 49)
	55	rssi = 2;
	56	else if (rssi <= 53)
	57	rssi = 3;
	58	else if (rssi <= 63)
	59	rssi = 4;
	60	else
	61	rssi = 5;
	62
	63	/*
	64	* Note that we must _not_ send LED_OFF since the driver
	65	* is going to calculate the value and might use it in a
	66	* division.
	67	*/
a2e1d52a ID	68	brightness = ((LED_FULL / 6) * rssi) + 1;
	69	if (brightness != led->led_dev.brightness) {
	70	led->led_dev.brightness_set(&led->led_dev, brightness);
	71	led->led_dev.brightness = brightness;
	72	}
3b640f21 ID	73	}
3b640f21 ID	74
9a95dba3	75	static void rt2x00led_led_simple(struct rt2x00_led *led, bool enabled)
61c2b682	76	{
9a95dba3	77	unsigned int brightness = enabled ? LED_FULL : LED_OFF;
61c2b682	78
9a95dba3	79	if (!(led->flags & LED_REGISTERED))
61c2b682 ID	80	return;
61c2b682 ID	81
9a95dba3 ID	82	led->led_dev.brightness_set(&led->led_dev, brightness);
9a95dba3 ID	83	led->led_dev.brightness = brightness;
61c2b682 ID	84	}
61c2b682 ID	85
9a95dba3	86	void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled)
3b640f21	87	{
9a95dba3 ID	88	if (rt2x00dev->led_qual.type == LED_TYPE_ACTIVITY)
	89	rt2x00led_led_simple(&rt2x00dev->led_qual, enabled);
	90	}
a2e1d52a	91
9a95dba3 ID	92	void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled)
	93	{
	94	if (rt2x00dev->led_assoc.type == LED_TYPE_ASSOC)
	95	rt2x00led_led_simple(&rt2x00dev->led_assoc, enabled);
a2e1d52a	96	}
3b640f21	97
a2e1d52a ID	98	void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled)
a2e1d52a ID	99	{
d1b29405	100	if (rt2x00dev->led_radio.type == LED_TYPE_RADIO)
9a95dba3	101	rt2x00led_led_simple(&rt2x00dev->led_radio, enabled);
3b640f21 ID	102	}
	103
	104	static int rt2x00leds_register_led(struct rt2x00_dev *rt2x00dev,
	105	struct rt2x00_led *led,
a2e1d52a	106	const char *name)
3b640f21 ID	107	{
	108	struct device *device = wiphy_dev(rt2x00dev->hw->wiphy);
	109	int retval;
	110
	111	led->led_dev.name = name;
9a95dba3 ID	112	led->led_dev.brightness = LED_OFF;
9a95dba3 ID	113
3b640f21 ID	114	retval = led_classdev_register(device, &led->led_dev);
	115	if (retval) {
	116	ERROR(rt2x00dev, "Failed to register led handler.\n");
	117	return retval;
	118	}
	119
a2e1d52a	120	led->flags \|= LED_REGISTERED;
3b640f21 ID	121
	122	return 0;
	123	}
	124
72fa559b	125	void rt2x00leds_register(struct rt2x00_dev *rt2x00dev)
3b640f21	126	{
3b640f21 ID	127	char dev_name[16];
	128	char name[32];
	129	int retval;
a2e1d52a ID	130	unsigned long on_period;
a2e1d52a ID	131	unsigned long off_period;
3b640f21 ID	132
	133	snprintf(dev_name, sizeof(dev_name), "%s-%s",
	134	rt2x00dev->ops->name, wiphy_name(rt2x00dev->hw->wiphy));
	135
a2e1d52a	136	if (rt2x00dev->led_radio.flags & LED_INITIALIZED) {
3b640f21 ID	137	snprintf(name, sizeof(name), "%s:radio", dev_name);
	138
	139	retval = rt2x00leds_register_led(rt2x00dev,
	140	&rt2x00dev->led_radio,
a2e1d52a	141	name);
3b640f21 ID	142	if (retval)
	143	goto exit_fail;
	144	}
	145
a2e1d52a	146	if (rt2x00dev->led_assoc.flags & LED_INITIALIZED) {
3b640f21 ID	147	snprintf(name, sizeof(name), "%s:assoc", dev_name);
	148
	149	retval = rt2x00leds_register_led(rt2x00dev,
	150	&rt2x00dev->led_assoc,
a2e1d52a	151	name);
3b640f21 ID	152	if (retval)
	153	goto exit_fail;
	154	}
	155
a2e1d52a	156	if (rt2x00dev->led_qual.flags & LED_INITIALIZED) {
3b640f21 ID	157	snprintf(name, sizeof(name), "%s:quality", dev_name);
3b640f21 ID	158
3b640f21 ID	159	retval = rt2x00leds_register_led(rt2x00dev,
3b640f21 ID	160	&rt2x00dev->led_qual,
a2e1d52a	161	name);
3b640f21 ID	162	if (retval)
	163	goto exit_fail;
	164	}
	165
a2e1d52a ID	166	/*
	167	* Initialize blink time to default value:
	168	* On period: 70ms
	169	* Off period: 30ms
	170	*/
	171	if (rt2x00dev->led_radio.led_dev.blink_set) {
	172	on_period = 70;
	173	off_period = 30;
	174	rt2x00dev->led_radio.led_dev.blink_set(
	175	&rt2x00dev->led_radio.led_dev, &on_period, &off_period);
	176	}
	177
72fa559b	178	return;
3b640f21 ID	179
	180	exit_fail:
	181	rt2x00leds_unregister(rt2x00dev);
3b640f21 ID	182	}
3b640f21 ID	183
3b640f21 ID	184	static void rt2x00leds_unregister_led(struct rt2x00_led *led)
3b640f21 ID	185	{
3b640f21	186	led_classdev_unregister(&led->led_dev);
9a95dba3 ID	187
	188	/*
	189	* This might look weird, but when we are unregistering while
	190	* suspended the led is already off, and since we haven't
	191	* fully resumed yet, access to the device might not be
	192	* possible yet.
	193	*/
	194	if (!(led->led_dev.flags & LED_SUSPENDED))
	195	led->led_dev.brightness_set(&led->led_dev, LED_OFF);
	196
a2e1d52a	197	led->flags &= ~LED_REGISTERED;
3b640f21 ID	198	}
	199
	200	void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev)
	201	{
a2e1d52a ID	202	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
	203	rt2x00leds_unregister_led(&rt2x00dev->led_qual);
	204	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
	205	rt2x00leds_unregister_led(&rt2x00dev->led_assoc);
	206	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
	207	rt2x00leds_unregister_led(&rt2x00dev->led_radio);
3b640f21 ID	208	}
3b640f21 ID	209
9a95dba3 ID	210	static inline void rt2x00leds_suspend_led(struct rt2x00_led *led)
	211	{
	212	led_classdev_suspend(&led->led_dev);
	213
	214	/* This shouldn't be needed, but just to be safe */
	215	led->led_dev.brightness_set(&led->led_dev, LED_OFF);
	216	led->led_dev.brightness = LED_OFF;
	217	}
	218
3b640f21 ID	219	void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev)
3b640f21 ID	220	{
a2e1d52a	221	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
9a95dba3	222	rt2x00leds_suspend_led(&rt2x00dev->led_qual);
a2e1d52a	223	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
9a95dba3	224	rt2x00leds_suspend_led(&rt2x00dev->led_assoc);
a2e1d52a	225	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
9a95dba3 ID	226	rt2x00leds_suspend_led(&rt2x00dev->led_radio);
	227	}
	228
	229	static inline void rt2x00leds_resume_led(struct rt2x00_led *led)
	230	{
	231	led_classdev_resume(&led->led_dev);
	232
	233	/* Device might have enabled the LEDS during resume */
	234	led->led_dev.brightness_set(&led->led_dev, LED_OFF);
	235	led->led_dev.brightness = LED_OFF;
3b640f21 ID	236	}
	237
	238	void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev)
	239	{
a2e1d52a	240	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
9a95dba3	241	rt2x00leds_resume_led(&rt2x00dev->led_radio);
a2e1d52a	242	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
9a95dba3	243	rt2x00leds_resume_led(&rt2x00dev->led_assoc);
a2e1d52a	244	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
9a95dba3	245	rt2x00leds_resume_led(&rt2x00dev->led_qual);
3b640f21	246	}