Commit | Line | Data |
---|---|---|
ab53d8af MA |
1 | /****************************************************************************** |
2 | * | |
901069c7 | 3 | * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved. |
ab53d8af MA |
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: | |
759ef89f | 22 | * Intel Linux Wireless <ilw@linux.intel.com> |
ab53d8af MA |
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> | |
ab53d8af | 30 | #include <linux/init.h> |
ab53d8af MA |
31 | #include <linux/delay.h> |
32 | #include <linux/skbuff.h> | |
33 | #include <linux/netdevice.h> | |
ab53d8af MA |
34 | #include <net/mac80211.h> |
35 | #include <linux/etherdevice.h> | |
36 | #include <asm/unaligned.h> | |
37 | ||
3e0d4cb1 | 38 | #include "iwl-dev.h" |
ab53d8af | 39 | #include "iwl-core.h" |
6b0184c4 | 40 | #include "iwl-agn.h" |
fee1247a | 41 | #include "iwl-io.h" |
bdfbf092 | 42 | #include "iwl-trans.h" |
48f20d35 | 43 | #include "iwl-shared.h" |
ab53d8af | 44 | |
3782cf4a WYG |
45 | /* Throughput OFF time(ms) ON time (ms) |
46 | * >300 25 25 | |
47 | * >200 to 300 40 40 | |
48 | * >100 to 200 55 55 | |
49 | * >70 to 100 65 65 | |
50 | * >50 to 70 75 75 | |
51 | * >20 to 50 85 85 | |
52 | * >10 to 20 95 95 | |
53 | * >5 to 10 110 110 | |
54 | * >1 to 5 130 130 | |
55 | * >0 to 1 167 167 | |
56 | * <=0 SOLID ON | |
57 | */ | |
5ed540ae | 58 | static const struct ieee80211_tpt_blink iwl_blink[] = { |
3782cf4a | 59 | { .throughput = 0, .blink_time = 334 }, |
5ed540ae WYG |
60 | { .throughput = 1 * 1024 - 1, .blink_time = 260 }, |
61 | { .throughput = 5 * 1024 - 1, .blink_time = 220 }, | |
62 | { .throughput = 10 * 1024 - 1, .blink_time = 190 }, | |
63 | { .throughput = 20 * 1024 - 1, .blink_time = 170 }, | |
64 | { .throughput = 50 * 1024 - 1, .blink_time = 150 }, | |
65 | { .throughput = 70 * 1024 - 1, .blink_time = 130 }, | |
66 | { .throughput = 100 * 1024 - 1, .blink_time = 110 }, | |
67 | { .throughput = 200 * 1024 - 1, .blink_time = 80 }, | |
68 | { .throughput = 300 * 1024 - 1, .blink_time = 50 }, | |
ab53d8af MA |
69 | }; |
70 | ||
e79b1ca7 WYG |
71 | /* Set led register off */ |
72 | void iwlagn_led_enable(struct iwl_priv *priv) | |
73 | { | |
83ed9015 | 74 | iwl_write32(bus(priv), CSR_LED_REG, CSR_LED_REG_TRUN_ON); |
e79b1ca7 WYG |
75 | } |
76 | ||
f2d0d0e2 WYG |
77 | /* |
78 | * Adjust led blink rate to compensate on a MAC Clock difference on every HW | |
6bb64697 WYG |
79 | * Led blink rate analysis showed an average deviation of 20% on 5000 series |
80 | * and up. | |
f2d0d0e2 WYG |
81 | * Need to compensate on the led on/off time per HW according to the deviation |
82 | * to achieve the desired led frequency | |
83 | * The calculation is: (100-averageDeviation)/100 * blinkTime | |
84 | * For code efficiency the calculation will be: | |
85 | * compensation = (100 - averageDeviation) * 64 / 100 | |
86 | * NewBlinkTime = (compensation * BlinkTime) / 64 | |
87 | */ | |
88 | static inline u8 iwl_blink_compensation(struct iwl_priv *priv, | |
89 | u8 time, u16 compensation) | |
90 | { | |
91 | if (!compensation) { | |
92 | IWL_ERR(priv, "undefined blink compensation: " | |
93 | "use pre-defined blinking time\n"); | |
94 | return time; | |
95 | } | |
96 | ||
97 | return (u8)((time * compensation) >> 6); | |
98 | } | |
99 | ||
e79b1ca7 WYG |
100 | static int iwl_send_led_cmd(struct iwl_priv *priv, struct iwl_led_cmd *led_cmd) |
101 | { | |
102 | struct iwl_host_cmd cmd = { | |
103 | .id = REPLY_LEDS_CMD, | |
3fa50738 JB |
104 | .len = { sizeof(struct iwl_led_cmd), }, |
105 | .data = { led_cmd, }, | |
e79b1ca7 | 106 | .flags = CMD_ASYNC, |
e79b1ca7 WYG |
107 | }; |
108 | u32 reg; | |
109 | ||
83ed9015 | 110 | reg = iwl_read32(bus(priv), CSR_LED_REG); |
e79b1ca7 | 111 | if (reg != (reg & CSR_LED_BSM_CTRL_MSK)) |
83ed9015 | 112 | iwl_write32(bus(priv), CSR_LED_REG, reg & CSR_LED_BSM_CTRL_MSK); |
e79b1ca7 | 113 | |
e6bb4c9c | 114 | return iwl_trans_send_cmd(trans(priv), &cmd); |
e79b1ca7 WYG |
115 | } |
116 | ||
ec1a7460 | 117 | /* Set led pattern command */ |
5ed540ae WYG |
118 | static int iwl_led_cmd(struct iwl_priv *priv, |
119 | unsigned long on, | |
120 | unsigned long off) | |
ab53d8af | 121 | { |
ec1a7460 | 122 | struct iwl_led_cmd led_cmd = { |
e932a609 | 123 | .id = IWL_LED_LINK, |
ab53d8af MA |
124 | .interval = IWL_DEF_LED_INTRVL |
125 | }; | |
5ed540ae | 126 | int ret; |
ab53d8af | 127 | |
63013ae3 | 128 | if (!test_bit(STATUS_READY, &priv->shrd->status)) |
5ed540ae | 129 | return -EBUSY; |
ec1a7460 | 130 | |
5ed540ae WYG |
131 | if (priv->blink_on == on && priv->blink_off == off) |
132 | return 0; | |
133 | ||
3782cf4a WYG |
134 | if (off == 0) { |
135 | /* led is SOLID_ON */ | |
136 | on = IWL_LED_SOLID; | |
137 | } | |
138 | ||
5ed540ae | 139 | IWL_DEBUG_LED(priv, "Led blink time compensation=%u\n", |
7cb1b088 | 140 | priv->cfg->base_params->led_compensation); |
5ed540ae | 141 | led_cmd.on = iwl_blink_compensation(priv, on, |
7cb1b088 | 142 | priv->cfg->base_params->led_compensation); |
5ed540ae | 143 | led_cmd.off = iwl_blink_compensation(priv, off, |
7cb1b088 | 144 | priv->cfg->base_params->led_compensation); |
ec1a7460 | 145 | |
e79b1ca7 | 146 | ret = iwl_send_led_cmd(priv, &led_cmd); |
5ed540ae WYG |
147 | if (!ret) { |
148 | priv->blink_on = on; | |
149 | priv->blink_off = off; | |
150 | } | |
151 | return ret; | |
ab53d8af | 152 | } |
ab53d8af | 153 | |
5ed540ae WYG |
154 | static void iwl_led_brightness_set(struct led_classdev *led_cdev, |
155 | enum led_brightness brightness) | |
ab53d8af | 156 | { |
5ed540ae WYG |
157 | struct iwl_priv *priv = container_of(led_cdev, struct iwl_priv, led); |
158 | unsigned long on = 0; | |
ab53d8af | 159 | |
5ed540ae WYG |
160 | if (brightness > 0) |
161 | on = IWL_LED_SOLID; | |
ab53d8af | 162 | |
5ed540ae | 163 | iwl_led_cmd(priv, on, 0); |
ab53d8af MA |
164 | } |
165 | ||
5ed540ae WYG |
166 | static int iwl_led_blink_set(struct led_classdev *led_cdev, |
167 | unsigned long *delay_on, | |
168 | unsigned long *delay_off) | |
ab53d8af | 169 | { |
5ed540ae | 170 | struct iwl_priv *priv = container_of(led_cdev, struct iwl_priv, led); |
a571ea4e | 171 | |
5ed540ae | 172 | return iwl_led_cmd(priv, *delay_on, *delay_off); |
ab53d8af MA |
173 | } |
174 | ||
5ed540ae | 175 | void iwl_leds_init(struct iwl_priv *priv) |
ab53d8af | 176 | { |
6b0184c4 | 177 | int mode = iwlagn_mod_params.led_mode; |
5ed540ae WYG |
178 | int ret; |
179 | ||
180 | if (mode == IWL_LED_DEFAULT) | |
181 | mode = priv->cfg->led_mode; | |
182 | ||
183 | priv->led.name = kasprintf(GFP_KERNEL, "%s-led", | |
184 | wiphy_name(priv->hw->wiphy)); | |
185 | priv->led.brightness_set = iwl_led_brightness_set; | |
186 | priv->led.blink_set = iwl_led_blink_set; | |
187 | priv->led.max_brightness = 1; | |
188 | ||
189 | switch (mode) { | |
190 | case IWL_LED_DEFAULT: | |
191 | WARN_ON(1); | |
192 | break; | |
193 | case IWL_LED_BLINK: | |
194 | priv->led.default_trigger = | |
195 | ieee80211_create_tpt_led_trigger(priv->hw, | |
196 | IEEE80211_TPT_LEDTRIG_FL_CONNECTED, | |
197 | iwl_blink, ARRAY_SIZE(iwl_blink)); | |
198 | break; | |
199 | case IWL_LED_RF_STATE: | |
200 | priv->led.default_trigger = | |
201 | ieee80211_get_radio_led_name(priv->hw); | |
202 | break; | |
ab53d8af MA |
203 | } |
204 | ||
26bfc0cf | 205 | ret = led_classdev_register(bus(priv)->dev, &priv->led); |
5ed540ae WYG |
206 | if (ret) { |
207 | kfree(priv->led.name); | |
ab53d8af MA |
208 | return; |
209 | } | |
ab53d8af | 210 | |
5ed540ae | 211 | priv->led_registered = true; |
ab53d8af | 212 | } |
ab53d8af | 213 | |
5ed540ae | 214 | void iwl_leds_exit(struct iwl_priv *priv) |
ab53d8af | 215 | { |
5ed540ae WYG |
216 | if (!priv->led_registered) |
217 | return; | |
218 | ||
219 | led_classdev_unregister(&priv->led); | |
220 | kfree(priv->led.name); | |
ab53d8af | 221 | } |