Merge branch 'omap2-clock' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind...
[linux-2.6] / drivers / net / wireless / iwlwifi / iwl-led.c
1 /******************************************************************************
2  *
3  * Copyright(c) 2003 - 2008 Intel Corporation. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of version 2 of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17  *
18  * The full GNU General Public License is included in this distribution in the
19  * file called LICENSE.
20  *
21  * Contact Information:
22  * James P. Ketrenos <ipw2100-admin@linux.intel.com>
23  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24  *
25  *****************************************************************************/
26
27
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/pci.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/delay.h>
34 #include <linux/skbuff.h>
35 #include <linux/netdevice.h>
36 #include <linux/wireless.h>
37 #include <net/mac80211.h>
38 #include <linux/etherdevice.h>
39 #include <asm/unaligned.h>
40
41 #include "iwl-dev.h"
42 #include "iwl-core.h"
43 #include "iwl-io.h"
44 #include "iwl-helpers.h"
45
46 #ifdef CONFIG_IWLWIFI_DEBUG
47 static const char *led_type_str[] = {
48         __stringify(IWL_LED_TRG_TX),
49         __stringify(IWL_LED_TRG_RX),
50         __stringify(IWL_LED_TRG_ASSOC),
51         __stringify(IWL_LED_TRG_RADIO),
52         NULL
53 };
54 #endif /* CONFIG_IWLWIFI_DEBUG */
55
56
57 static const struct {
58         u16 tpt;
59         u8 on_time;
60         u8 off_time;
61 } blink_tbl[] =
62 {
63         {300, 25, 25},
64         {200, 40, 40},
65         {100, 55, 55},
66         {70, 65, 65},
67         {50, 75, 75},
68         {20, 85, 85},
69         {15, 95, 95 },
70         {10, 110, 110},
71         {5, 130, 130},
72         {0, 167, 167},
73 /* SOLID_ON */
74         {-1, IWL_LED_SOLID, 0}
75 };
76
77 #define IWL_1MB_RATE (128 * 1024)
78 #define IWL_LED_THRESHOLD (16)
79 #define IWL_MAX_BLINK_TBL (ARRAY_SIZE(blink_tbl) - 1) /* exclude SOLID_ON */
80 #define IWL_SOLID_BLINK_IDX (ARRAY_SIZE(blink_tbl) - 1)
81
82 /*  [0-256] -> [0..8] FIXME: we need [0..10] */
83 static inline int iwl_brightness_to_idx(enum led_brightness brightness)
84 {
85         return fls(0x000000FF & (u32)brightness);
86 }
87
88 /* Send led command */
89 static int iwl_send_led_cmd(struct iwl_priv *priv, struct iwl_led_cmd *led_cmd)
90 {
91         struct iwl_host_cmd cmd = {
92                 .id = REPLY_LEDS_CMD,
93                 .len = sizeof(struct iwl_led_cmd),
94                 .data = led_cmd,
95                 .meta.flags = CMD_ASYNC,
96                 .meta.u.callback = NULL,
97         };
98         u32 reg;
99
100         reg = iwl_read32(priv, CSR_LED_REG);
101         if (reg != (reg & CSR_LED_BSM_CTRL_MSK))
102                 iwl_write32(priv, CSR_LED_REG, reg & CSR_LED_BSM_CTRL_MSK);
103
104         return iwl_send_cmd(priv, &cmd);
105 }
106
107 /* Set led pattern command */
108 static int iwl4965_led_pattern(struct iwl_priv *priv, int led_id,
109                                unsigned int idx)
110 {
111         struct iwl_led_cmd led_cmd = {
112                 .id = led_id,
113                 .interval = IWL_DEF_LED_INTRVL
114         };
115
116         BUG_ON(idx > IWL_MAX_BLINK_TBL);
117
118         led_cmd.on = blink_tbl[idx].on_time;
119         led_cmd.off = blink_tbl[idx].off_time;
120
121         return iwl_send_led_cmd(priv, &led_cmd);
122 }
123
124 /* Set led register off */
125 static int iwl4965_led_on_reg(struct iwl_priv *priv, int led_id)
126 {
127         IWL_DEBUG_LED("led on %d\n", led_id);
128         iwl_write32(priv, CSR_LED_REG, CSR_LED_REG_TRUN_ON);
129         return 0;
130 }
131
132 #if 0
133 /* Set led on command */
134 static int iwl4965_led_on(struct iwl_priv *priv, int led_id)
135 {
136         struct iwl_led_cmd led_cmd = {
137                 .id = led_id,
138                 .on = IWL_LED_SOLID,
139                 .off = 0,
140                 .interval = IWL_DEF_LED_INTRVL
141         };
142         return iwl_send_led_cmd(priv, &led_cmd);
143 }
144
145 /* Set led off command */
146 int iwl4965_led_off(struct iwl_priv *priv, int led_id)
147 {
148         struct iwl_led_cmd led_cmd = {
149                 .id = led_id,
150                 .on = 0,
151                 .off = 0,
152                 .interval = IWL_DEF_LED_INTRVL
153         };
154         IWL_DEBUG_LED("led off %d\n", led_id);
155         return iwl_send_led_cmd(priv, &led_cmd);
156 }
157 #endif
158
159
160 /* Set led register off */
161 static int iwl4965_led_off_reg(struct iwl_priv *priv, int led_id)
162 {
163         IWL_DEBUG_LED("LED Reg off\n");
164         iwl_write32(priv, CSR_LED_REG, CSR_LED_REG_TRUN_OFF);
165         return 0;
166 }
167
168 /*
169  * Set led register in case of disassociation according to rfkill state
170  */
171 static int iwl_led_associate(struct iwl_priv *priv, int led_id)
172 {
173         IWL_DEBUG_LED("Associated\n");
174         priv->allow_blinking = 1;
175         return iwl4965_led_on_reg(priv, led_id);
176 }
177 static int iwl_led_disassociate(struct iwl_priv *priv, int led_id)
178 {
179         priv->allow_blinking = 0;
180         if (iwl_is_rfkill(priv))
181                 iwl4965_led_off_reg(priv, led_id);
182         else
183                 iwl4965_led_on_reg(priv, led_id);
184
185         return 0;
186 }
187
188 /*
189  * brightness call back function for Tx/Rx LED
190  */
191 static int iwl_led_associated(struct iwl_priv *priv, int led_id)
192 {
193         if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
194             !test_bit(STATUS_READY, &priv->status))
195                 return 0;
196
197
198         /* start counting Tx/Rx bytes */
199         if (!priv->last_blink_time && priv->allow_blinking)
200                 priv->last_blink_time = jiffies;
201         return 0;
202 }
203
204 /*
205  * brightness call back for association and radio
206  */
207 static void iwl_led_brightness_set(struct led_classdev *led_cdev,
208                                        enum led_brightness brightness)
209 {
210         struct iwl_led *led = container_of(led_cdev, struct iwl_led, led_dev);
211         struct iwl_priv *priv = led->priv;
212
213         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
214                 return;
215
216
217         IWL_DEBUG_LED("Led type = %s brightness = %d\n",
218                         led_type_str[led->type], brightness);
219         switch (brightness) {
220         case LED_FULL:
221                 if (led->led_on)
222                         led->led_on(priv, IWL_LED_LINK);
223                 break;
224         case LED_OFF:
225                 if (led->led_off)
226                         led->led_off(priv, IWL_LED_LINK);
227                 break;
228         default:
229                 if (led->led_pattern) {
230                         int idx = iwl_brightness_to_idx(brightness);
231                         led->led_pattern(priv, IWL_LED_LINK, idx);
232                 }
233                 break;
234         }
235 }
236
237
238
239 /*
240  * Register led class with the system
241  */
242 static int iwl_leds_register_led(struct iwl_priv *priv, struct iwl_led *led,
243                                    enum led_type type, u8 set_led,
244                                    char *trigger)
245 {
246         struct device *device = wiphy_dev(priv->hw->wiphy);
247         int ret;
248
249         led->led_dev.name = led->name;
250         led->led_dev.brightness_set = iwl_led_brightness_set;
251         led->led_dev.default_trigger = trigger;
252
253         led->priv = priv;
254         led->type = type;
255
256         ret = led_classdev_register(device, &led->led_dev);
257         if (ret) {
258                 IWL_ERROR("Error: failed to register led handler.\n");
259                 return ret;
260         }
261
262         led->registered = 1;
263
264         if (set_led && led->led_on)
265                 led->led_on(priv, IWL_LED_LINK);
266
267         return 0;
268 }
269
270
271 /*
272  * calculate blink rate according to last 2 sec Tx/Rx activities
273  */
274 static int iwl_get_blink_rate(struct iwl_priv *priv)
275 {
276         int i;
277         u64 current_tpt = priv->tx_stats[2].bytes;
278         /* FIXME: + priv->rx_stats[2].bytes; */
279         s64 tpt = current_tpt - priv->led_tpt;
280
281         if (tpt < 0) /* wrapparound */
282                 tpt = -tpt;
283
284         IWL_DEBUG_LED("tpt %lld current_tpt %llu\n",
285                 (long long)tpt,
286                 (unsigned long long)current_tpt);
287         priv->led_tpt = current_tpt;
288
289         if (!priv->allow_blinking)
290                 i = IWL_MAX_BLINK_TBL;
291         else
292                 for (i = 0; i < IWL_MAX_BLINK_TBL; i++)
293                         if (tpt  > (blink_tbl[i].tpt * IWL_1MB_RATE))
294                                 break;
295
296         IWL_DEBUG_LED("LED BLINK IDX=%d", i);
297         return i;
298 }
299
300 /*
301  * this function called from handler. Since setting Led command can
302  * happen very frequent we postpone led command to be called from
303  * REPLY handler so we know ucode is up
304  */
305 void iwl_leds_background(struct iwl_priv *priv)
306 {
307         u8 blink_idx;
308
309         if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
310                 priv->last_blink_time = 0;
311                 return;
312         }
313         if (iwl_is_rfkill(priv)) {
314                 priv->last_blink_time = 0;
315                 return;
316         }
317
318         if (!priv->allow_blinking) {
319                 priv->last_blink_time = 0;
320                 if (priv->last_blink_rate != IWL_SOLID_BLINK_IDX) {
321                         priv->last_blink_rate = IWL_SOLID_BLINK_IDX;
322                         iwl4965_led_pattern(priv, IWL_LED_LINK,
323                                             IWL_SOLID_BLINK_IDX);
324                 }
325                 return;
326         }
327         if (!priv->last_blink_time ||
328             !time_after(jiffies, priv->last_blink_time +
329                         msecs_to_jiffies(1000)))
330                 return;
331
332         blink_idx = iwl_get_blink_rate(priv);
333
334         /* call only if blink rate change */
335         if (blink_idx != priv->last_blink_rate)
336                 iwl4965_led_pattern(priv, IWL_LED_LINK, blink_idx);
337
338         priv->last_blink_time = jiffies;
339         priv->last_blink_rate = blink_idx;
340 }
341 EXPORT_SYMBOL(iwl_leds_background);
342
343 /* Register all led handler */
344 int iwl_leds_register(struct iwl_priv *priv)
345 {
346         char *trigger;
347         int ret;
348
349         priv->last_blink_rate = 0;
350         priv->led_tpt = 0;
351         priv->last_blink_time = 0;
352         priv->allow_blinking = 0;
353
354         trigger = ieee80211_get_radio_led_name(priv->hw);
355         snprintf(priv->led[IWL_LED_TRG_RADIO].name,
356                  sizeof(priv->led[IWL_LED_TRG_RADIO].name), "iwl-%s:radio",
357                  wiphy_name(priv->hw->wiphy));
358
359         priv->led[IWL_LED_TRG_RADIO].led_on = iwl4965_led_on_reg;
360         priv->led[IWL_LED_TRG_RADIO].led_off = iwl4965_led_off_reg;
361         priv->led[IWL_LED_TRG_RADIO].led_pattern = NULL;
362
363         ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_RADIO],
364                                    IWL_LED_TRG_RADIO, 1, trigger);
365         if (ret)
366                 goto exit_fail;
367
368         trigger = ieee80211_get_assoc_led_name(priv->hw);
369         snprintf(priv->led[IWL_LED_TRG_ASSOC].name,
370                  sizeof(priv->led[IWL_LED_TRG_ASSOC].name), "iwl-%s:assoc",
371                  wiphy_name(priv->hw->wiphy));
372
373         ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_ASSOC],
374                                    IWL_LED_TRG_ASSOC, 0, trigger);
375
376         /* for assoc always turn led on */
377         priv->led[IWL_LED_TRG_ASSOC].led_on = iwl_led_associate;
378         priv->led[IWL_LED_TRG_ASSOC].led_off = iwl_led_disassociate;
379         priv->led[IWL_LED_TRG_ASSOC].led_pattern = NULL;
380
381         if (ret)
382                 goto exit_fail;
383
384         trigger = ieee80211_get_rx_led_name(priv->hw);
385         snprintf(priv->led[IWL_LED_TRG_RX].name,
386                  sizeof(priv->led[IWL_LED_TRG_RX].name), "iwl-%s:RX",
387                  wiphy_name(priv->hw->wiphy));
388
389         ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_RX],
390                                    IWL_LED_TRG_RX, 0, trigger);
391
392         priv->led[IWL_LED_TRG_RX].led_on = iwl_led_associated;
393         priv->led[IWL_LED_TRG_RX].led_off = iwl_led_associated;
394         priv->led[IWL_LED_TRG_RX].led_pattern = iwl4965_led_pattern;
395
396         if (ret)
397                 goto exit_fail;
398
399         trigger = ieee80211_get_tx_led_name(priv->hw);
400         snprintf(priv->led[IWL_LED_TRG_TX].name,
401                  sizeof(priv->led[IWL_LED_TRG_TX].name), "iwl-%s:TX",
402                  wiphy_name(priv->hw->wiphy));
403
404         ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_TX],
405                                    IWL_LED_TRG_TX, 0, trigger);
406
407         priv->led[IWL_LED_TRG_TX].led_on = iwl_led_associated;
408         priv->led[IWL_LED_TRG_TX].led_off = iwl_led_associated;
409         priv->led[IWL_LED_TRG_TX].led_pattern = iwl4965_led_pattern;
410
411         if (ret)
412                 goto exit_fail;
413
414         return 0;
415
416 exit_fail:
417         iwl_leds_unregister(priv);
418         return ret;
419 }
420 EXPORT_SYMBOL(iwl_leds_register);
421
422 /* unregister led class */
423 static void iwl_leds_unregister_led(struct iwl_led *led, u8 set_led)
424 {
425         if (!led->registered)
426                 return;
427
428         led_classdev_unregister(&led->led_dev);
429
430         if (set_led)
431                 led->led_dev.brightness_set(&led->led_dev, LED_OFF);
432         led->registered = 0;
433 }
434
435 /* Unregister all led handlers */
436 void iwl_leds_unregister(struct iwl_priv *priv)
437 {
438         iwl_leds_unregister_led(&priv->led[IWL_LED_TRG_ASSOC], 0);
439         iwl_leds_unregister_led(&priv->led[IWL_LED_TRG_RX], 0);
440         iwl_leds_unregister_led(&priv->led[IWL_LED_TRG_TX], 0);
441         iwl_leds_unregister_led(&priv->led[IWL_LED_TRG_RADIO], 1);
442 }
443 EXPORT_SYMBOL(iwl_leds_unregister);
444