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