f2ea3f05f6e13f9caedf37b309c6229057847db0
[linux-2.6.git] / drivers / net / wireless / iwlwifi / iwl-power.c
1 /******************************************************************************
2  *
3  * Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
4  *
5  * Portions of this file are derived from the ipw3945 project, as well
6  * as portions of the ieee80211 subsystem header files.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of version 2 of the GNU General Public License as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along with
18  * this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20  *
21  * The full GNU General Public License is included in this distribution in the
22  * file called LICENSE.
23  *
24  * Contact Information:
25  *  Intel Linux Wireless <ilw@linux.intel.com>
26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27  *****************************************************************************/
28
29
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/init.h>
33
34 #include <net/mac80211.h>
35
36 #include "iwl-eeprom.h"
37 #include "iwl-dev.h"
38 #include "iwl-core.h"
39 #include "iwl-commands.h"
40 #include "iwl-debug.h"
41 #include "iwl-power.h"
42
43 /*
44  * Setting power level allow the card to go to sleep when not busy.
45  *
46  * The power level is set to INDEX_1 (the least deep state) by
47  * default, and will, in the future, be the deepest state unless
48  * otherwise required by pm_qos network latency requirements.
49  *
50  * Using INDEX_1 without pm_qos is ok because mac80211 will disable
51  * PS when even checking every beacon for the TIM bit would exceed
52  * the required latency.
53  */
54
55 #define IWL_POWER_RANGE_0_MAX  (2)
56 #define IWL_POWER_RANGE_1_MAX  (10)
57
58
59 #define NOSLP cpu_to_le16(0), 0, 0
60 #define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK, 0, 0
61 #define TU_TO_USEC 1024
62 #define SLP_TOUT(T) cpu_to_le32((T) * TU_TO_USEC)
63 #define SLP_VEC(X0, X1, X2, X3, X4) {cpu_to_le32(X0), \
64                                      cpu_to_le32(X1), \
65                                      cpu_to_le32(X2), \
66                                      cpu_to_le32(X3), \
67                                      cpu_to_le32(X4)}
68 /* default power management (not Tx power) table values */
69 /* for DTIM period 0 through IWL_POWER_RANGE_0_MAX */
70 static const struct iwl_power_vec_entry range_0[IWL_POWER_NUM] = {
71         {{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
72         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 2, 2, 0xFF)}, 0},
73         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 2, 2, 0xFF)}, 0},
74         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 2, 2, 2, 0xFF)}, 0},
75         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 2, 4, 4, 0xFF)}, 1},
76         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 2, 4, 6, 0xFF)}, 2}
77 };
78
79
80 /* for DTIM period IWL_POWER_RANGE_0_MAX + 1 through IWL_POWER_RANGE_1_MAX */
81 static const struct iwl_power_vec_entry range_1[IWL_POWER_NUM] = {
82         {{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
83         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 4)}, 0},
84         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(1, 2, 3, 4, 7)}, 0},
85         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 4, 6, 7, 9)}, 0},
86         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 4, 6, 9, 10)}, 1},
87         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(2, 4, 7, 10, 10)}, 2}
88 };
89
90 /* for DTIM period > IWL_POWER_RANGE_1_MAX */
91 static const struct iwl_power_vec_entry range_2[IWL_POWER_NUM] = {
92         {{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
93         {{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 0xFF)}, 0},
94         {{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(2, 4, 6, 7, 0xFF)}, 0},
95         {{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
96         {{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
97         {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 0xFF)}, 0}
98 };
99
100
101 /* set card power command */
102 static int iwl_set_power(struct iwl_priv *priv, void *cmd)
103 {
104         return iwl_send_cmd_pdu(priv, POWER_TABLE_CMD,
105                                 sizeof(struct iwl_powertable_cmd), cmd);
106 }
107
108 /* initialize to default */
109 static void iwl_power_init_handle(struct iwl_priv *priv)
110 {
111         struct iwl_power_mgr *pow_data;
112         int size = sizeof(struct iwl_power_vec_entry) * IWL_POWER_NUM;
113         struct iwl_powertable_cmd *cmd;
114         int i;
115         u16 lctl;
116
117         IWL_DEBUG_POWER(priv, "Initialize power \n");
118
119         pow_data = &priv->power_data;
120
121         memset(pow_data, 0, sizeof(*pow_data));
122
123         memcpy(&pow_data->pwr_range_0[0], &range_0[0], size);
124         memcpy(&pow_data->pwr_range_1[0], &range_1[0], size);
125         memcpy(&pow_data->pwr_range_2[0], &range_2[0], size);
126
127         lctl = iwl_pcie_link_ctl(priv);
128
129         IWL_DEBUG_POWER(priv, "adjust power command flags\n");
130
131         for (i = 0; i < IWL_POWER_NUM; i++) {
132                 cmd = &pow_data->pwr_range_0[i].cmd;
133
134                 if (lctl & PCI_CFG_LINK_CTRL_VAL_L0S_EN)
135                         cmd->flags &= ~IWL_POWER_PCI_PM_MSK;
136                 else
137                         cmd->flags |= IWL_POWER_PCI_PM_MSK;
138         }
139 }
140
141 /* adjust power command according to DTIM period and power level*/
142 static int iwl_update_power_cmd(struct iwl_priv *priv,
143                                 struct iwl_powertable_cmd *cmd, u16 mode)
144 {
145         struct iwl_power_vec_entry *range;
146         struct iwl_power_mgr *pow_data;
147         int i;
148         u32 max_sleep = 0;
149         u8 period;
150         bool skip;
151
152         if (mode > IWL_POWER_INDEX_5) {
153                 IWL_DEBUG_POWER(priv, "Error invalid power mode \n");
154                 return -EINVAL;
155         }
156
157         pow_data = &priv->power_data;
158
159         if (pow_data->dtim_period <= IWL_POWER_RANGE_0_MAX)
160                 range = &pow_data->pwr_range_0[0];
161         else if (pow_data->dtim_period <= IWL_POWER_RANGE_1_MAX)
162                 range = &pow_data->pwr_range_1[0];
163         else
164                 range = &pow_data->pwr_range_2[0];
165
166         period = pow_data->dtim_period;
167         memcpy(cmd, &range[mode].cmd, sizeof(struct iwl_powertable_cmd));
168
169         if (period == 0) {
170                 period = 1;
171                 skip = false;
172         } else {
173                 skip = !!range[mode].no_dtim;
174         }
175
176         if (skip) {
177                 __le32 slp_itrvl = cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1];
178                 max_sleep = le32_to_cpu(slp_itrvl);
179                 if (max_sleep == 0xFF)
180                         max_sleep = period * (skip + 1);
181                 else if (max_sleep >  period)
182                         max_sleep = (le32_to_cpu(slp_itrvl) / period) * period;
183                 cmd->flags |= IWL_POWER_SLEEP_OVER_DTIM_MSK;
184         } else {
185                 max_sleep = period;
186                 cmd->flags &= ~IWL_POWER_SLEEP_OVER_DTIM_MSK;
187         }
188
189         for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
190                 if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep)
191                         cmd->sleep_interval[i] = cpu_to_le32(max_sleep);
192
193         IWL_DEBUG_POWER(priv, "Flags value = 0x%08X\n", cmd->flags);
194         IWL_DEBUG_POWER(priv, "Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
195         IWL_DEBUG_POWER(priv, "Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
196         IWL_DEBUG_POWER(priv, "Sleep interval vector = { %d , %d , %d , %d , %d }\n",
197                         le32_to_cpu(cmd->sleep_interval[0]),
198                         le32_to_cpu(cmd->sleep_interval[1]),
199                         le32_to_cpu(cmd->sleep_interval[2]),
200                         le32_to_cpu(cmd->sleep_interval[3]),
201                         le32_to_cpu(cmd->sleep_interval[4]));
202
203         return 0;
204 }
205
206
207 /*
208  * compute the final power mode index
209  */
210 int iwl_power_update_mode(struct iwl_priv *priv, bool force)
211 {
212         struct iwl_power_mgr *setting = &(priv->power_data);
213         int ret = 0;
214         u16 uninitialized_var(final_mode);
215         bool update_chains;
216
217         /* Don't update the RX chain when chain noise calibration is running */
218         update_chains = priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE ||
219                         priv->chain_noise_data.state == IWL_CHAIN_NOISE_ALIVE;
220
221         final_mode = priv->power_data.user_power_setting;
222
223         if (setting->power_disabled)
224                 final_mode = IWL_POWER_MODE_CAM;
225
226         if (iwl_is_ready_rf(priv) &&
227             ((setting->power_mode != final_mode) || force)) {
228                 struct iwl_powertable_cmd cmd;
229
230                 if (final_mode != IWL_POWER_MODE_CAM)
231                         set_bit(STATUS_POWER_PMI, &priv->status);
232
233                 iwl_update_power_cmd(priv, &cmd, final_mode);
234                 cmd.keep_alive_beacons = 0;
235
236                 if (final_mode == IWL_POWER_INDEX_5)
237                         cmd.flags |= IWL_POWER_FAST_PD;
238
239                 ret = iwl_set_power(priv, &cmd);
240
241                 if (final_mode == IWL_POWER_MODE_CAM)
242                         clear_bit(STATUS_POWER_PMI, &priv->status);
243
244                 if (priv->cfg->ops->lib->update_chain_flags && update_chains)
245                         priv->cfg->ops->lib->update_chain_flags(priv);
246                 else
247                         IWL_DEBUG_POWER(priv, "Cannot update the power, chain noise "
248                                         "calibration running: %d\n",
249                                         priv->chain_noise_data.state);
250                 if (!ret)
251                         setting->power_mode = final_mode;
252         }
253
254         return ret;
255 }
256 EXPORT_SYMBOL(iwl_power_update_mode);
257
258 /* set user_power_setting */
259 int iwl_power_set_user_mode(struct iwl_priv *priv, u16 mode)
260 {
261         if (mode >= IWL_POWER_NUM)
262                 return -EINVAL;
263
264         priv->power_data.user_power_setting = mode;
265
266         return iwl_power_update_mode(priv, 0);
267 }
268 EXPORT_SYMBOL(iwl_power_set_user_mode);
269
270 /* initialize to default */
271 void iwl_power_initialize(struct iwl_priv *priv)
272 {
273         iwl_power_init_handle(priv);
274         priv->power_data.user_power_setting = IWL_POWER_INDEX_1;
275         /* default to disabled until mac80211 says otherwise */
276         priv->power_data.power_disabled = 1;
277 }
278 EXPORT_SYMBOL(iwl_power_initialize);