Commit | Line | Data |
---|---|---|
3b640f21 | 1 | /* |
9c9a0d14 | 2 | Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com> |
3b640f21 ID |
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 | } |
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; |
81 | ||
9a95dba3 ID |
82 | led->led_dev.brightness_set(&led->led_dev, brightness); |
83 | led->led_dev.brightness = brightness; | |
61c2b682 ID |
84 | } |
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) |
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; |
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; |
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) { |
b34196d7 | 137 | snprintf(name, sizeof(name), "%s::radio", dev_name); |
3b640f21 ID |
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) { |
b34196d7 | 147 | snprintf(name, sizeof(name), "%s::assoc", dev_name); |
3b640f21 ID |
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) { |
b34196d7 | 157 | snprintf(name, sizeof(name), "%s::quality", dev_name); |
3b640f21 | 158 | |
3b640f21 ID |
159 | retval = rt2x00leds_register_led(rt2x00dev, |
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 | } |
183 | ||
3b640f21 ID |
184 | static void rt2x00leds_unregister_led(struct rt2x00_led *led) |
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 | } |
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) |
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 | } |