[mirror_ubuntu-zesty-kernel.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;
	}
}

void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled)
{
	struct rt2x00_led *led = &rt2x00dev->led_assoc;
	unsigned int brightness;

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

	brightness = enabled ? LED_FULL : LED_OFF;
	if (brightness != led->led_dev.brightness) {
		led->led_dev.brightness_set(&led->led_dev, brightness);
		led->led_dev.brightness = brightness;
	}
}

void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled)
{
	struct rt2x00_led *led = &rt2x00dev->led_radio;
	unsigned int brightness;

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

	brightness = enabled ? LED_FULL : LED_OFF;
	if (brightness != led->led_dev.brightness) {
		led->led_dev.brightness_set(&led->led_dev, brightness);
		led->led_dev.brightness = brightness;
	}
}

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;

	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);
	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);
}

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

void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev)
{
	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
		led_classdev_resume(&rt2x00dev->led_radio.led_dev);
	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
		led_classdev_resume(&rt2x00dev->led_assoc.led_dev);
	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
		led_classdev_resume(&rt2x00dev->led_qual.led_dev);
}
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
a2e1d52a	75	void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled)
3b640f21	76	{
a2e1d52a ID	77	struct rt2x00_led *led = &rt2x00dev->led_assoc;
a2e1d52a ID	78	unsigned int brightness;
3b640f21	79
a2e1d52a ID	80	if ((led->type != LED_TYPE_ASSOC) \|\| !(led->flags & LED_REGISTERED))
	81	return;
	82
	83	brightness = enabled ? LED_FULL : LED_OFF;
	84	if (brightness != led->led_dev.brightness) {
	85	led->led_dev.brightness_set(&led->led_dev, brightness);
	86	led->led_dev.brightness = brightness;
3b640f21	87	}
a2e1d52a	88	}
3b640f21	89
a2e1d52a ID	90	void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled)
	91	{
	92	struct rt2x00_led *led = &rt2x00dev->led_radio;
	93	unsigned int brightness;
3b640f21	94
a2e1d52a ID	95	if ((led->type != LED_TYPE_RADIO) \|\| !(led->flags & LED_REGISTERED))
	96	return;
	97
	98	brightness = enabled ? LED_FULL : LED_OFF;
	99	if (brightness != led->led_dev.brightness) {
	100	led->led_dev.brightness_set(&led->led_dev, brightness);
	101	led->led_dev.brightness = brightness;
	102	}
3b640f21 ID	103	}
	104
	105	static int rt2x00leds_register_led(struct rt2x00_dev *rt2x00dev,
	106	struct rt2x00_led *led,
a2e1d52a	107	const char *name)
3b640f21 ID	108	{
	109	struct device *device = wiphy_dev(rt2x00dev->hw->wiphy);
	110	int retval;
	111
	112	led->led_dev.name = name;
3b640f21 ID	113
	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);
3b640f21	187	led->led_dev.brightness_set(&led->led_dev, LED_OFF);
a2e1d52a	188	led->flags &= ~LED_REGISTERED;
3b640f21 ID	189	}
	190
	191	void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev)
	192	{
a2e1d52a ID	193	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
	194	rt2x00leds_unregister_led(&rt2x00dev->led_qual);
	195	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
	196	rt2x00leds_unregister_led(&rt2x00dev->led_assoc);
	197	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
	198	rt2x00leds_unregister_led(&rt2x00dev->led_radio);
3b640f21 ID	199	}
	200
	201	void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev)
	202	{
a2e1d52a	203	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
3b640f21	204	led_classdev_suspend(&rt2x00dev->led_qual.led_dev);
a2e1d52a	205	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
3b640f21	206	led_classdev_suspend(&rt2x00dev->led_assoc.led_dev);
a2e1d52a	207	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
3b640f21 ID	208	led_classdev_suspend(&rt2x00dev->led_radio.led_dev);
	209	}
	210
	211	void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev)
	212	{
a2e1d52a	213	if (rt2x00dev->led_radio.flags & LED_REGISTERED)
3b640f21	214	led_classdev_resume(&rt2x00dev->led_radio.led_dev);
a2e1d52a	215	if (rt2x00dev->led_assoc.flags & LED_REGISTERED)
3b640f21	216	led_classdev_resume(&rt2x00dev->led_assoc.led_dev);
a2e1d52a	217	if (rt2x00dev->led_qual.flags & LED_REGISTERED)
3b640f21 ID	218	led_classdev_resume(&rt2x00dev->led_qual.led_dev);
3b640f21 ID	219	}