[IWLWIFI]: add iwlwifi wireless drivers
[linux-2.6.git] / drivers / net / wireless / iwlwifi / iwl-commands.h
1 /******************************************************************************
2  *
3  * This file is provided under a dual BSD/GPLv2 license.  When using or
4  * redistributing this file, you may do so under either license.
5  *
6  * GPL LICENSE SUMMARY
7  *
8  * Copyright(c) 2005 - 2007 Intel Corporation. All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of version 2 of the GNU Geeral Public License as
12  * published by the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
22  * USA
23  *
24  * The full GNU General Public License is included in this distribution
25  * in the file called LICENSE.GPL.
26  *
27  * Contact Information:
28  * James P. Ketrenos <ipw2100-admin@linux.intel.com>
29  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30  *
31  * BSD LICENSE
32  *
33  * Copyright(c) 2005 - 2007 Intel Corporation. All rights reserved.
34  * All rights reserved.
35  *
36  * Redistribution and use in source and binary forms, with or without
37  * modification, are permitted provided that the following conditions
38  * are met:
39  *
40  *  * Redistributions of source code must retain the above copyright
41  *    notice, this list of conditions and the following disclaimer.
42  *  * Redistributions in binary form must reproduce the above copyright
43  *    notice, this list of conditions and the following disclaimer in
44  *    the documentation and/or other materials provided with the
45  *    distribution.
46  *  * Neither the name Intel Corporation nor the names of its
47  *    contributors may be used to endorse or promote products derived
48  *    from this software without specific prior written permission.
49  *
50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61  *
62  *****************************************************************************/
63
64 #ifndef __iwl_commands_h__
65 #define __iwl_commands_h__
66
67 enum {
68         REPLY_ALIVE = 0x1,
69         REPLY_ERROR = 0x2,
70
71         /* RXON and QOS commands */
72         REPLY_RXON = 0x10,
73         REPLY_RXON_ASSOC = 0x11,
74         REPLY_QOS_PARAM = 0x13,
75         REPLY_RXON_TIMING = 0x14,
76
77         /* Multi-Station support */
78         REPLY_ADD_STA = 0x18,
79         REPLY_REMOVE_STA = 0x19,        /* not used */
80         REPLY_REMOVE_ALL_STA = 0x1a,    /* not used */
81
82         /* RX, TX, LEDs */
83 #if IWL == 3945
84         REPLY_3945_RX = 0x1b,           /* 3945 only */
85 #endif
86         REPLY_TX = 0x1c,
87         REPLY_RATE_SCALE = 0x47,        /* 3945 only */
88         REPLY_LEDS_CMD = 0x48,
89         REPLY_TX_LINK_QUALITY_CMD = 0x4e, /* 4965 only */
90
91         /* 802.11h related */
92         RADAR_NOTIFICATION = 0x70,      /* not used */
93         REPLY_QUIET_CMD = 0x71,         /* not used */
94         REPLY_CHANNEL_SWITCH = 0x72,
95         CHANNEL_SWITCH_NOTIFICATION = 0x73,
96         REPLY_SPECTRUM_MEASUREMENT_CMD = 0x74,
97         SPECTRUM_MEASURE_NOTIFICATION = 0x75,
98
99         /* Power Management */
100         POWER_TABLE_CMD = 0x77,
101         PM_SLEEP_NOTIFICATION = 0x7A,
102         PM_DEBUG_STATISTIC_NOTIFIC = 0x7B,
103
104         /* Scan commands and notifications */
105         REPLY_SCAN_CMD = 0x80,
106         REPLY_SCAN_ABORT_CMD = 0x81,
107         SCAN_START_NOTIFICATION = 0x82,
108         SCAN_RESULTS_NOTIFICATION = 0x83,
109         SCAN_COMPLETE_NOTIFICATION = 0x84,
110
111         /* IBSS/AP commands */
112         BEACON_NOTIFICATION = 0x90,
113         REPLY_TX_BEACON = 0x91,
114         WHO_IS_AWAKE_NOTIFICATION = 0x94,       /* not used */
115
116         /* Miscellaneous commands */
117         QUIET_NOTIFICATION = 0x96,              /* not used */
118         REPLY_TX_PWR_TABLE_CMD = 0x97,
119         MEASURE_ABORT_NOTIFICATION = 0x99,      /* not used */
120
121         /* BT config command */
122         REPLY_BT_CONFIG = 0x9b,
123
124         /* 4965 Statistics */
125         REPLY_STATISTICS_CMD = 0x9c,
126         STATISTICS_NOTIFICATION = 0x9d,
127
128         /* RF-KILL commands and notifications */
129         REPLY_CARD_STATE_CMD = 0xa0,
130         CARD_STATE_NOTIFICATION = 0xa1,
131
132         /* Missed beacons notification */
133         MISSED_BEACONS_NOTIFICATION = 0xa2,
134
135 #if IWL == 4965
136         REPLY_CT_KILL_CONFIG_CMD = 0xa4,
137         SENSITIVITY_CMD = 0xa8,
138         REPLY_PHY_CALIBRATION_CMD = 0xb0,
139         REPLY_RX_PHY_CMD = 0xc0,
140         REPLY_RX_MPDU_CMD = 0xc1,
141         REPLY_4965_RX = 0xc3,
142         REPLY_COMPRESSED_BA = 0xc5,
143 #endif
144         REPLY_MAX = 0xff
145 };
146
147 /******************************************************************************
148  * (0)
149  * Header
150  *
151  *****************************************************************************/
152
153 #define IWL_CMD_FAILED_MSK 0x40
154
155 struct iwl_cmd_header {
156         u8 cmd;
157         u8 flags;
158         /* We have 15 LSB to use as we please (MSB indicates
159          * a frame Rx'd from the HW).  We encode the following
160          * information into the sequence field:
161          *
162          *  0:7    index in fifo
163          *  8:13   fifo selection
164          * 14:14   bit indicating if this packet references the 'extra'
165          *         storage at the end of the memory queue
166          * 15:15   (Rx indication)
167          *
168          */
169         __le16 sequence;
170
171         /* command data follows immediately */
172         u8 data[0];
173 } __attribute__ ((packed));
174
175 /******************************************************************************
176  * (0a)
177  * Alive and Error Commands & Responses:
178  *
179  *****************************************************************************/
180
181 #define UCODE_VALID_OK  __constant_cpu_to_le32(0x1)
182 #define INITIALIZE_SUBTYPE    (9)
183
184 /*
185  * REPLY_ALIVE = 0x1 (response only, not a command)
186  */
187 struct iwl_alive_resp {
188         u8 ucode_minor;
189         u8 ucode_major;
190         __le16 reserved1;
191         u8 sw_rev[8];
192         u8 ver_type;
193         u8 ver_subtype;
194         __le16 reserved2;
195         __le32 log_event_table_ptr;
196         __le32 error_event_table_ptr;
197         __le32 timestamp;
198         __le32 is_valid;
199 } __attribute__ ((packed));
200
201 struct iwl_init_alive_resp {
202         u8 ucode_minor;
203         u8 ucode_major;
204         __le16 reserved1;
205         u8 sw_rev[8];
206         u8 ver_type;
207         u8 ver_subtype;
208         __le16 reserved2;
209         __le32 log_event_table_ptr;
210         __le32 error_event_table_ptr;
211         __le32 timestamp;
212         __le32 is_valid;
213
214 #if IWL == 4965
215         /* calibration values from "initialize" uCode */
216         __le32 voltage;         /* signed */
217         __le32 therm_r1[2];     /* signed 1st for normal, 2nd for FAT channel */
218         __le32 therm_r2[2];     /* signed */
219         __le32 therm_r3[2];     /* signed */
220         __le32 therm_r4[2];     /* signed */
221         __le32 tx_atten[5][2];  /* signed MIMO gain comp, 5 freq groups,
222                                  * 2 Tx chains */
223 #endif
224 } __attribute__ ((packed));
225
226 union tsf {
227         u8 byte[8];
228         __le16 word[4];
229         __le32 dw[2];
230 };
231
232 /*
233  * REPLY_ERROR = 0x2 (response only, not a command)
234  */
235 struct iwl_error_resp {
236         __le32 error_type;
237         u8 cmd_id;
238         u8 reserved1;
239         __le16 bad_cmd_seq_num;
240 #if IWL == 3945
241         __le16 reserved2;
242 #endif
243         __le32 error_info;
244         union tsf timestamp;
245 } __attribute__ ((packed));
246
247 /******************************************************************************
248  * (1)
249  * RXON Commands & Responses:
250  *
251  *****************************************************************************/
252
253 /*
254  * Rx config defines & structure
255  */
256 /* rx_config device types  */
257 enum {
258         RXON_DEV_TYPE_AP = 1,
259         RXON_DEV_TYPE_ESS = 3,
260         RXON_DEV_TYPE_IBSS = 4,
261         RXON_DEV_TYPE_SNIFFER = 6,
262 };
263
264 /* rx_config flags */
265 /* band & modulation selection */
266 #define RXON_FLG_BAND_24G_MSK           __constant_cpu_to_le32(1 << 0)
267 #define RXON_FLG_CCK_MSK                __constant_cpu_to_le32(1 << 1)
268 /* auto detection enable */
269 #define RXON_FLG_AUTO_DETECT_MSK        __constant_cpu_to_le32(1 << 2)
270 /* TGg protection when tx */
271 #define RXON_FLG_TGG_PROTECT_MSK        __constant_cpu_to_le32(1 << 3)
272 /* cck short slot & preamble */
273 #define RXON_FLG_SHORT_SLOT_MSK          __constant_cpu_to_le32(1 << 4)
274 #define RXON_FLG_SHORT_PREAMBLE_MSK     __constant_cpu_to_le32(1 << 5)
275 /* antenna selection */
276 #define RXON_FLG_DIS_DIV_MSK            __constant_cpu_to_le32(1 << 7)
277 #define RXON_FLG_ANT_SEL_MSK            __constant_cpu_to_le32(0x0f00)
278 #define RXON_FLG_ANT_A_MSK              __constant_cpu_to_le32(1 << 8)
279 #define RXON_FLG_ANT_B_MSK              __constant_cpu_to_le32(1 << 9)
280 /* radar detection enable */
281 #define RXON_FLG_RADAR_DETECT_MSK       __constant_cpu_to_le32(1 << 12)
282 #define RXON_FLG_TGJ_NARROW_BAND_MSK    __constant_cpu_to_le32(1 << 13)
283 /* rx response to host with 8-byte TSF
284 * (according to ON_AIR deassertion) */
285 #define RXON_FLG_TSF2HOST_MSK           __constant_cpu_to_le32(1 << 15)
286
287 /* rx_config filter flags */
288 /* accept all data frames */
289 #define RXON_FILTER_PROMISC_MSK         __constant_cpu_to_le32(1 << 0)
290 /* pass control & management to host */
291 #define RXON_FILTER_CTL2HOST_MSK        __constant_cpu_to_le32(1 << 1)
292 /* accept multi-cast */
293 #define RXON_FILTER_ACCEPT_GRP_MSK      __constant_cpu_to_le32(1 << 2)
294 /* don't decrypt uni-cast frames */
295 #define RXON_FILTER_DIS_DECRYPT_MSK     __constant_cpu_to_le32(1 << 3)
296 /* don't decrypt multi-cast frames */
297 #define RXON_FILTER_DIS_GRP_DECRYPT_MSK __constant_cpu_to_le32(1 << 4)
298 /* STA is associated */
299 #define RXON_FILTER_ASSOC_MSK           __constant_cpu_to_le32(1 << 5)
300 /* transfer to host non bssid beacons in associated state */
301 #define RXON_FILTER_BCON_AWARE_MSK      __constant_cpu_to_le32(1 << 6)
302
303 /*
304  * REPLY_RXON = 0x10 (command, has simple generic response)
305  */
306 struct iwl_rxon_cmd {
307         u8 node_addr[6];
308         __le16 reserved1;
309         u8 bssid_addr[6];
310         __le16 reserved2;
311         u8 wlap_bssid_addr[6];
312         __le16 reserved3;
313         u8 dev_type;
314         u8 air_propagation;
315 #if IWL == 3945
316         __le16 reserved4;
317 #elif IWL == 4965
318         __le16 rx_chain;
319 #endif
320         u8 ofdm_basic_rates;
321         u8 cck_basic_rates;
322         __le16 assoc_id;
323         __le32 flags;
324         __le32 filter_flags;
325         __le16 channel;
326 #if IWL == 3945
327         __le16 reserved5;
328 #elif IWL == 4965
329         u8 ofdm_ht_single_stream_basic_rates;
330         u8 ofdm_ht_dual_stream_basic_rates;
331 #endif
332 } __attribute__ ((packed));
333
334 /*
335  * REPLY_RXON_ASSOC = 0x11 (command, has simple generic response)
336  */
337 struct iwl_rxon_assoc_cmd {
338         __le32 flags;
339         __le32 filter_flags;
340         u8 ofdm_basic_rates;
341         u8 cck_basic_rates;
342 #if IWL == 4965
343         u8 ofdm_ht_single_stream_basic_rates;
344         u8 ofdm_ht_dual_stream_basic_rates;
345         __le16 rx_chain_select_flags;
346 #endif
347         __le16 reserved;
348 } __attribute__ ((packed));
349
350 /*
351  * REPLY_RXON_TIMING = 0x14 (command, has simple generic response)
352  */
353 struct iwl_rxon_time_cmd {
354         union tsf timestamp;
355         __le16 beacon_interval;
356         __le16 atim_window;
357         __le32 beacon_init_val;
358         __le16 listen_interval;
359         __le16 reserved;
360 } __attribute__ ((packed));
361
362 struct iwl_tx_power {
363         u8 tx_gain;             /* gain for analog radio */
364         u8 dsp_atten;           /* gain for DSP */
365 } __attribute__ ((packed));
366
367 #if IWL == 3945
368 struct iwl_power_per_rate {
369         u8 rate;                /* plcp */
370         struct iwl_tx_power tpc;
371         u8 reserved;
372 } __attribute__ ((packed));
373
374 #elif IWL == 4965
375 #define POWER_TABLE_NUM_ENTRIES                 33
376 #define POWER_TABLE_NUM_HT_OFDM_ENTRIES         32
377 #define POWER_TABLE_CCK_ENTRY                   32
378 struct tx_power_dual_stream {
379         __le32 dw;
380 } __attribute__ ((packed));
381
382 struct iwl_tx_power_db {
383         struct tx_power_dual_stream power_tbl[POWER_TABLE_NUM_ENTRIES];
384 } __attribute__ ((packed));
385 #endif
386
387 /*
388  * REPLY_CHANNEL_SWITCH = 0x72 (command, has simple generic response)
389  */
390 struct iwl_channel_switch_cmd {
391         u8 band;
392         u8 expect_beacon;
393         __le16 channel;
394         __le32 rxon_flags;
395         __le32 rxon_filter_flags;
396         __le32 switch_time;
397 #if IWL == 3945
398         struct iwl_power_per_rate power[IWL_MAX_RATES];
399 #elif IWL == 4965
400         struct iwl_tx_power_db tx_power;
401 #endif
402 } __attribute__ ((packed));
403
404 /*
405  * CHANNEL_SWITCH_NOTIFICATION = 0x73 (notification only, not a command)
406  */
407 struct iwl_csa_notification {
408         __le16 band;
409         __le16 channel;
410         __le32 status;          /* 0 - OK, 1 - fail */
411 } __attribute__ ((packed));
412
413 /******************************************************************************
414  * (2)
415  * Quality-of-Service (QOS) Commands & Responses:
416  *
417  *****************************************************************************/
418 struct iwl_ac_qos {
419         __le16 cw_min;
420         __le16 cw_max;
421         u8 aifsn;
422         u8 reserved1;
423         __le16 edca_txop;
424 } __attribute__ ((packed));
425
426 /* QoS flags defines */
427 #define QOS_PARAM_FLG_UPDATE_EDCA_MSK   __constant_cpu_to_le32(0x01)
428 #define QOS_PARAM_FLG_TGN_MSK           __constant_cpu_to_le32(0x02)
429 #define QOS_PARAM_FLG_TXOP_TYPE_MSK     __constant_cpu_to_le32(0x10)
430
431 /*
432  *  TXFIFO Queue number defines
433  */
434 /* number of Access categories (AC) (EDCA), queues 0..3 */
435 #define AC_NUM                4
436
437 /*
438  * REPLY_QOS_PARAM = 0x13 (command, has simple generic response)
439  */
440 struct iwl_qosparam_cmd {
441         __le32 qos_flags;
442         struct iwl_ac_qos ac[AC_NUM];
443 } __attribute__ ((packed));
444
445 /******************************************************************************
446  * (3)
447  * Add/Modify Stations Commands & Responses:
448  *
449  *****************************************************************************/
450 /*
451  * Multi station support
452  */
453 #define IWL_AP_ID               0
454 #define IWL_MULTICAST_ID        1
455 #define IWL_STA_ID              2
456
457 #define IWL3945_BROADCAST_ID    24
458 #define IWL3945_STATION_COUNT   25
459
460 #define IWL4965_BROADCAST_ID    31
461 #define IWL4965_STATION_COUNT   32
462
463 #define IWL_STATION_COUNT       32      /* MAX(3945,4965)*/
464 #define IWL_INVALID_STATION     255
465
466 #if IWL == 3945
467 #define STA_FLG_TX_RATE_MSK             __constant_cpu_to_le32(1<<2);
468 #endif
469 #define STA_FLG_PWR_SAVE_MSK            __constant_cpu_to_le32(1<<8);
470
471 #define STA_CONTROL_MODIFY_MSK          0x01
472
473 /* key flags __le16*/
474 #define STA_KEY_FLG_ENCRYPT_MSK __constant_cpu_to_le16(0x7)
475 #define STA_KEY_FLG_NO_ENC      __constant_cpu_to_le16(0x0)
476 #define STA_KEY_FLG_WEP         __constant_cpu_to_le16(0x1)
477 #define STA_KEY_FLG_CCMP        __constant_cpu_to_le16(0x2)
478 #define STA_KEY_FLG_TKIP        __constant_cpu_to_le16(0x3)
479
480 #define STA_KEY_FLG_KEYID_POS   8
481 #define STA_KEY_FLG_INVALID     __constant_cpu_to_le16(0x0800)
482
483 /* modify flags  */
484 #define STA_MODIFY_KEY_MASK             0x01
485 #define STA_MODIFY_TID_DISABLE_TX       0x02
486 #define STA_MODIFY_TX_RATE_MSK          0x04
487 #define STA_MODIFY_ADDBA_TID_MSK        0x08
488 #define STA_MODIFY_DELBA_TID_MSK        0x10
489 #define BUILD_RAxTID(sta_id, tid)       (((sta_id) << 4) + (tid))
490
491 /*
492  * Antenna masks:
493  * bit14:15 01 B inactive, A active
494  *          10 B active, A inactive
495  *          11 Both active
496  */
497 #define RATE_MCS_ANT_A_POS      14
498 #define RATE_MCS_ANT_B_POS      15
499 #define RATE_MCS_ANT_A_MSK      0x4000
500 #define RATE_MCS_ANT_B_MSK      0x8000
501 #define RATE_MCS_ANT_AB_MSK     0xc000
502
503 struct iwl_keyinfo {
504         __le16 key_flags;
505         u8 tkip_rx_tsc_byte2;   /* TSC[2] for key mix ph1 detection */
506         u8 reserved1;
507         __le16 tkip_rx_ttak[5]; /* 10-byte unicast TKIP TTAK */
508         __le16 reserved2;
509         u8 key[16];             /* 16-byte unicast decryption key */
510 } __attribute__ ((packed));
511
512 struct sta_id_modify {
513         u8 addr[ETH_ALEN];
514         __le16 reserved1;
515         u8 sta_id;
516         u8 modify_mask;
517         __le16 reserved2;
518 } __attribute__ ((packed));
519
520 /*
521  * REPLY_ADD_STA = 0x18 (command)
522  */
523 struct iwl_addsta_cmd {
524         u8 mode;
525         u8 reserved[3];
526         struct sta_id_modify sta;
527         struct iwl_keyinfo key;
528         __le32 station_flags;
529         __le32 station_flags_msk;
530         __le16 tid_disable_tx;
531 #if IWL == 3945
532         __le16 rate_n_flags;
533 #else
534         __le16  reserved1;
535 #endif
536         u8 add_immediate_ba_tid;
537         u8 remove_immediate_ba_tid;
538         __le16 add_immediate_ba_ssn;
539 #if IWL == 4965
540         __le32 reserved2;
541 #endif
542 } __attribute__ ((packed));
543
544 /*
545  * REPLY_ADD_STA = 0x18 (response)
546  */
547 struct iwl_add_sta_resp {
548         u8 status;
549 } __attribute__ ((packed));
550
551 #define ADD_STA_SUCCESS_MSK              0x1
552
553 /******************************************************************************
554  * (4)
555  * Rx Responses:
556  *
557  *****************************************************************************/
558
559 struct iwl_rx_frame_stats {
560         u8 phy_count;
561         u8 id;
562         u8 rssi;
563         u8 agc;
564         __le16 sig_avg;
565         __le16 noise_diff;
566         u8 payload[0];
567 } __attribute__ ((packed));
568
569 struct iwl_rx_frame_hdr {
570         __le16 channel;
571         __le16 phy_flags;
572         u8 reserved1;
573         u8 rate;
574         __le16 len;
575         u8 payload[0];
576 } __attribute__ ((packed));
577
578 #define RX_RES_STATUS_NO_CRC32_ERROR    __constant_cpu_to_le32(1 << 0)
579 #define RX_RES_STATUS_NO_RXE_OVERFLOW   __constant_cpu_to_le32(1 << 1)
580
581 #define RX_RES_PHY_FLAGS_BAND_24_MSK    __constant_cpu_to_le16(1 << 0)
582 #define RX_RES_PHY_FLAGS_MOD_CCK_MSK            __constant_cpu_to_le16(1 << 1)
583 #define RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK     __constant_cpu_to_le16(1 << 2)
584 #define RX_RES_PHY_FLAGS_NARROW_BAND_MSK        __constant_cpu_to_le16(1 << 3)
585 #define RX_RES_PHY_FLAGS_ANTENNA_MSK            __constant_cpu_to_le16(0xf0)
586
587 #define RX_RES_STATUS_SEC_TYPE_MSK      (0x7 << 8)
588 #define RX_RES_STATUS_SEC_TYPE_NONE     (0x0 << 8)
589 #define RX_RES_STATUS_SEC_TYPE_WEP      (0x1 << 8)
590 #define RX_RES_STATUS_SEC_TYPE_CCMP     (0x2 << 8)
591 #define RX_RES_STATUS_SEC_TYPE_TKIP     (0x3 << 8)
592
593 #define RX_RES_STATUS_DECRYPT_TYPE_MSK  (0x3 << 11)
594 #define RX_RES_STATUS_NOT_DECRYPT       (0x0 << 11)
595 #define RX_RES_STATUS_DECRYPT_OK        (0x3 << 11)
596 #define RX_RES_STATUS_BAD_ICV_MIC       (0x1 << 11)
597 #define RX_RES_STATUS_BAD_KEY_TTAK      (0x2 << 11)
598
599 struct iwl_rx_frame_end {
600         __le32 status;
601         __le64 timestamp;
602         __le32 beacon_timestamp;
603 } __attribute__ ((packed));
604
605 /*
606  * REPLY_3945_RX = 0x1b (response only, not a command)
607  *
608  * NOTE:  DO NOT dereference from casts to this structure
609  * It is provided only for calculating minimum data set size.
610  * The actual offsets of the hdr and end are dynamic based on
611  * stats.phy_count
612  */
613 struct iwl_rx_frame {
614         struct iwl_rx_frame_stats stats;
615         struct iwl_rx_frame_hdr hdr;
616         struct iwl_rx_frame_end end;
617 } __attribute__ ((packed));
618
619 /* Fixed (non-configurable) rx data from phy */
620 #define RX_PHY_FLAGS_ANTENNAE_OFFSET            (4)
621 #define RX_PHY_FLAGS_ANTENNAE_MASK              (0x70)
622 #define IWL_AGC_DB_MASK         (0x3f80)        /* MASK(7,13) */
623 #define IWL_AGC_DB_POS          (7)
624 struct iwl4965_rx_non_cfg_phy {
625         __le16 ant_selection;   /* ant A bit 4, ant B bit 5, ant C bit 6 */
626         __le16 agc_info;        /* agc code 0:6, agc dB 7:13, reserved 14:15 */
627         u8 rssi_info[6];        /* we use even entries, 0/2/4 for A/B/C rssi */
628         u8 pad[0];
629 } __attribute__ ((packed));
630
631 /*
632  * REPLY_4965_RX = 0xc3 (response only, not a command)
633  * Used only for legacy (non 11n) frames.
634  */
635 #define RX_RES_PHY_CNT 14
636 struct iwl4965_rx_phy_res {
637         u8 non_cfg_phy_cnt;     /* non configurable DSP phy data byte count */
638         u8 cfg_phy_cnt;         /* configurable DSP phy data byte count */
639         u8 stat_id;             /* configurable DSP phy data set ID */
640         u8 reserved1;
641         __le64 timestamp;       /* TSF at on air rise */
642         __le32 beacon_time_stamp; /* beacon at on-air rise */
643         __le16 phy_flags;       /* general phy flags: band, modulation, ... */
644         __le16 channel;         /* channel number */
645         __le16 non_cfg_phy[RX_RES_PHY_CNT];     /* upto 14 phy entries */
646         __le32 reserved2;
647         __le32 rate_n_flags;
648         __le16 byte_count;              /* frame's byte-count */
649         __le16 reserved3;
650 } __attribute__ ((packed));
651
652 struct iwl4965_rx_mpdu_res_start {
653         __le16 byte_count;
654         __le16 reserved;
655 } __attribute__ ((packed));
656
657
658 /******************************************************************************
659  * (5)
660  * Tx Commands & Responses:
661  *
662  *****************************************************************************/
663
664 /* Tx flags */
665 #define TX_CMD_FLG_RTS_MSK __constant_cpu_to_le32(1 << 1)
666 #define TX_CMD_FLG_CTS_MSK __constant_cpu_to_le32(1 << 2)
667 #define TX_CMD_FLG_ACK_MSK __constant_cpu_to_le32(1 << 3)
668 #define TX_CMD_FLG_STA_RATE_MSK __constant_cpu_to_le32(1 << 4)
669 #define TX_CMD_FLG_IMM_BA_RSP_MASK  __constant_cpu_to_le32(1 << 6)
670 #define TX_CMD_FLG_FULL_TXOP_PROT_MSK __constant_cpu_to_le32(1 << 7)
671 #define TX_CMD_FLG_ANT_SEL_MSK __constant_cpu_to_le32(0xf00)
672 #define TX_CMD_FLG_ANT_A_MSK __constant_cpu_to_le32(1 << 8)
673 #define TX_CMD_FLG_ANT_B_MSK __constant_cpu_to_le32(1 << 9)
674
675 /* ucode ignores BT priority for this frame */
676 #define TX_CMD_FLG_BT_DIS_MSK __constant_cpu_to_le32(1 << 12)
677
678 /* ucode overrides sequence control */
679 #define TX_CMD_FLG_SEQ_CTL_MSK __constant_cpu_to_le32(1 << 13)
680
681 /* signal that this frame is non-last MPDU */
682 #define TX_CMD_FLG_MORE_FRAG_MSK __constant_cpu_to_le32(1 << 14)
683
684 /* calculate TSF in outgoing frame */
685 #define TX_CMD_FLG_TSF_MSK __constant_cpu_to_le32(1 << 16)
686
687 /* activate TX calibration. */
688 #define TX_CMD_FLG_CALIB_MSK __constant_cpu_to_le32(1 << 17)
689
690 /* signals that 2 bytes pad was inserted
691    after the MAC header */
692 #define TX_CMD_FLG_MH_PAD_MSK __constant_cpu_to_le32(1 << 20)
693
694 /* HCCA-AP - disable duration overwriting. */
695 #define TX_CMD_FLG_DUR_MSK __constant_cpu_to_le32(1 << 25)
696
697 /*
698  * TX command security control
699  */
700 #define TX_CMD_SEC_WEP          0x01
701 #define TX_CMD_SEC_CCM          0x02
702 #define TX_CMD_SEC_TKIP         0x03
703 #define TX_CMD_SEC_MSK          0x03
704 #define TX_CMD_SEC_SHIFT        6
705 #define TX_CMD_SEC_KEY128       0x08
706
707 /*
708  * TX command Frame life time
709  */
710
711 struct iwl_dram_scratch {
712         u8 try_cnt;
713         u8 bt_kill_cnt;
714         __le16 reserved;
715 } __attribute__ ((packed));
716
717 /*
718  * REPLY_TX = 0x1c (command)
719  */
720 struct iwl_tx_cmd {
721         __le16 len;
722         __le16 next_frame_len;
723         __le32 tx_flags;
724 #if IWL == 3945
725         u8 rate;
726         u8 sta_id;
727         u8 tid_tspec;
728 #elif IWL == 4965
729         struct iwl_dram_scratch scratch;
730         __le32 rate_n_flags;
731         u8 sta_id;
732 #endif
733         u8 sec_ctl;
734 #if IWL == 4965
735         u8 initial_rate_index;
736         u8 reserved;
737 #endif
738         u8 key[16];
739 #if IWL == 3945
740         union {
741                 u8 byte[8];
742                 __le16 word[4];
743                 __le32 dw[2];
744         } tkip_mic;
745         __le32 next_frame_info;
746 #elif IWL == 4965
747         __le16 next_frame_flags;
748         __le16 reserved2;
749 #endif
750         union {
751                 __le32 life_time;
752                 __le32 attempt;
753         } stop_time;
754 #if IWL == 3945
755         u8 supp_rates[2];
756 #elif IWL == 4965
757         __le32 dram_lsb_ptr;
758         u8 dram_msb_ptr;
759 #endif
760         u8 rts_retry_limit;     /*byte 50 */
761         u8 data_retry_limit;    /*byte 51 */
762 #if IWL == 4965
763         u8 tid_tspec;
764 #endif
765         union {
766                 __le16 pm_frame_timeout;
767                 __le16 attempt_duration;
768         } timeout;
769         __le16 driver_txop;
770         u8 payload[0];
771         struct ieee80211_hdr hdr[0];
772 } __attribute__ ((packed));
773
774 /* TX command response is sent after *all* transmission attempts.
775  *
776  * NOTES:
777  *
778  * TX_STATUS_FAIL_NEXT_FRAG
779  *
780  * If the fragment flag in the MAC header for the frame being transmitted
781  * is set and there is insufficient time to transmit the next frame, the
782  * TX status will be returned with 'TX_STATUS_FAIL_NEXT_FRAG'.
783  *
784  * TX_STATUS_FIFO_UNDERRUN
785  *
786  * Indicates the host did not provide bytes to the FIFO fast enough while
787  * a TX was in progress.
788  *
789  * TX_STATUS_FAIL_MGMNT_ABORT
790  *
791  * This status is only possible if the ABORT ON MGMT RX parameter was
792  * set to true with the TX command.
793  *
794  * If the MSB of the status parameter is set then an abort sequence is
795  * required.  This sequence consists of the host activating the TX Abort
796  * control line, and then waiting for the TX Abort command response.  This
797  * indicates that a the device is no longer in a transmit state, and that the
798  * command FIFO has been cleared.  The host must then deactivate the TX Abort
799  * control line.  Receiving is still allowed in this case.
800  */
801 enum {
802         TX_STATUS_SUCCESS = 0x01,
803         TX_STATUS_DIRECT_DONE = 0x02,
804         TX_STATUS_FAIL_SHORT_LIMIT = 0x82,
805         TX_STATUS_FAIL_LONG_LIMIT = 0x83,
806         TX_STATUS_FAIL_FIFO_UNDERRUN = 0x84,
807         TX_STATUS_FAIL_MGMNT_ABORT = 0x85,
808         TX_STATUS_FAIL_NEXT_FRAG = 0x86,
809         TX_STATUS_FAIL_LIFE_EXPIRE = 0x87,
810         TX_STATUS_FAIL_DEST_PS = 0x88,
811         TX_STATUS_FAIL_ABORTED = 0x89,
812         TX_STATUS_FAIL_BT_RETRY = 0x8a,
813         TX_STATUS_FAIL_STA_INVALID = 0x8b,
814         TX_STATUS_FAIL_FRAG_DROPPED = 0x8c,
815         TX_STATUS_FAIL_TID_DISABLE = 0x8d,
816         TX_STATUS_FAIL_FRAME_FLUSHED = 0x8e,
817         TX_STATUS_FAIL_INSUFFICIENT_CF_POLL = 0x8f,
818         TX_STATUS_FAIL_TX_LOCKED = 0x90,
819         TX_STATUS_FAIL_NO_BEACON_ON_RADAR = 0x91,
820 };
821
822 #define TX_PACKET_MODE_REGULAR          0x0000
823 #define TX_PACKET_MODE_BURST_SEQ        0x0100
824 #define TX_PACKET_MODE_BURST_FIRST      0x0200
825
826 enum {
827         TX_POWER_PA_NOT_ACTIVE = 0x0,
828 };
829
830 enum {
831         TX_STATUS_MSK = 0x000000ff,     /* bits 0:7 */
832         TX_STATUS_DELAY_MSK = 0x00000040,
833         TX_STATUS_ABORT_MSK = 0x00000080,
834         TX_PACKET_MODE_MSK = 0x0000ff00,        /* bits 8:15 */
835         TX_FIFO_NUMBER_MSK = 0x00070000,        /* bits 16:18 */
836         TX_RESERVED = 0x00780000,       /* bits 19:22 */
837         TX_POWER_PA_DETECT_MSK = 0x7f800000,    /* bits 23:30 */
838         TX_ABORT_REQUIRED_MSK = 0x80000000,     /* bits 31:31 */
839 };
840
841 /* *******************************
842  * TX aggregation state
843  ******************************* */
844
845 enum {
846         AGG_TX_STATE_TRANSMITTED = 0x00,
847         AGG_TX_STATE_UNDERRUN_MSK = 0x01,
848         AGG_TX_STATE_BT_PRIO_MSK = 0x02,
849         AGG_TX_STATE_FEW_BYTES_MSK = 0x04,
850         AGG_TX_STATE_ABORT_MSK = 0x08,
851         AGG_TX_STATE_LAST_SENT_TTL_MSK = 0x10,
852         AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK = 0x20,
853         AGG_TX_STATE_LAST_SENT_BT_KILL_MSK = 0x40,
854         AGG_TX_STATE_SCD_QUERY_MSK = 0x80,
855         AGG_TX_STATE_TEST_BAD_CRC32_MSK = 0x100,
856         AGG_TX_STATE_RESPONSE_MSK = 0x1ff,
857         AGG_TX_STATE_DUMP_TX_MSK = 0x200,
858         AGG_TX_STATE_DELAY_TX_MSK = 0x400
859 };
860
861 #define AGG_TX_STATE_LAST_SENT_MSK \
862 (AGG_TX_STATE_LAST_SENT_TTL_MSK | \
863  AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK | \
864  AGG_TX_STATE_LAST_SENT_BT_KILL_MSK)
865
866 #define AGG_TX_STATE_TRY_CNT_POS 12
867 #define AGG_TX_STATE_TRY_CNT_MSK 0xf000
868
869 #define AGG_TX_STATE_SEQ_NUM_POS 16
870 #define AGG_TX_STATE_SEQ_NUM_MSK 0xffff0000
871
872 /*
873  * REPLY_TX = 0x1c (response)
874  */
875 #if IWL == 4965
876 struct iwl_tx_resp {
877         u8 frame_count;         /* 1 no aggregation, >1 aggregation */
878         u8 bt_kill_count;
879         u8 failure_rts;
880         u8 failure_frame;
881         __le32 rate_n_flags;
882         __le16 wireless_media_time;
883         __le16 reserved;
884         __le32 pa_power1;
885         __le32 pa_power2;
886         __le32 status;  /* TX status (for aggregation status of 1st frame) */
887 } __attribute__ ((packed));
888
889 #elif IWL == 3945
890 struct iwl_tx_resp {
891         u8 failure_rts;
892         u8 failure_frame;
893         u8 bt_kill_count;
894         u8 rate;
895         __le32 wireless_media_time;
896         __le32 status;  /* TX status (for aggregation status of 1st frame) */
897 } __attribute__ ((packed));
898 #endif
899
900 /*
901  * REPLY_COMPRESSED_BA = 0xc5 (response only, not a command)
902  */
903 struct iwl_compressed_ba_resp {
904         __le32 sta_addr_lo32;
905         __le16 sta_addr_hi16;
906         __le16 reserved;
907         u8 sta_id;
908         u8 tid;
909         __le16 ba_seq_ctl;
910         __le32 ba_bitmap0;
911         __le32 ba_bitmap1;
912         __le16 scd_flow;
913         __le16 scd_ssn;
914 } __attribute__ ((packed));
915
916 /*
917  * REPLY_TX_PWR_TABLE_CMD = 0x97 (command, has simple generic response)
918  */
919 struct iwl_txpowertable_cmd {
920         u8 band;                /* 0: 5 GHz, 1: 2.4 GHz */
921         u8 reserved;
922         __le16 channel;
923 #if IWL == 3945
924         struct iwl_power_per_rate power[IWL_MAX_RATES];
925 #elif IWL == 4965
926         struct iwl_tx_power_db tx_power;
927 #endif
928 } __attribute__ ((packed));
929
930 #if IWL == 3945
931 struct iwl_rate_scaling_info {
932         __le16 rate_n_flags;
933         u8 try_cnt;
934         u8 next_rate_index;
935 } __attribute__ ((packed));
936
937 /**
938  * struct iwl_rate_scaling_cmd - Rate Scaling Command & Response
939  *
940  * REPLY_RATE_SCALE = 0x47 (command, has simple generic response)
941  *
942  * NOTE: The table of rates passed to the uCode via the
943  * RATE_SCALE command sets up the corresponding order of
944  * rates used for all related commands, including rate
945  * masks, etc.
946  *
947  * For example, if you set 9MB (PLCP 0x0f) as the first
948  * rate in the rate table, the bit mask for that rate
949  * when passed through ofdm_basic_rates on the REPLY_RXON
950  * command would be bit 0 (1<<0)
951  */
952 struct iwl_rate_scaling_cmd {
953         u8 table_id;
954         u8 reserved[3];
955         struct iwl_rate_scaling_info table[IWL_MAX_RATES];
956 } __attribute__ ((packed));
957
958 #elif IWL == 4965
959
960 /*RS_NEW_API: only TLC_RTS remains and moved to bit 0 */
961 #define  LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK    (1<<0)
962
963 #define  LINK_QUAL_AC_NUM AC_NUM
964 #define  LINK_QUAL_MAX_RETRY_NUM 16
965
966 #define  LINK_QUAL_ANT_A_MSK (1<<0)
967 #define  LINK_QUAL_ANT_B_MSK (1<<1)
968 #define  LINK_QUAL_ANT_MSK   (LINK_QUAL_ANT_A_MSK|LINK_QUAL_ANT_B_MSK)
969
970 struct iwl_link_qual_general_params {
971         u8 flags;
972         u8 mimo_delimiter;
973         u8 single_stream_ant_msk;
974         u8 dual_stream_ant_msk;
975         u8 start_rate_index[LINK_QUAL_AC_NUM];
976 } __attribute__ ((packed));
977
978 struct iwl_link_qual_agg_params {
979         __le16 agg_time_limit;
980         u8 agg_dis_start_th;
981         u8 agg_frame_cnt_limit;
982         __le32 reserved;
983 } __attribute__ ((packed));
984
985 /*
986  * REPLY_TX_LINK_QUALITY_CMD = 0x4e (command, has simple generic response)
987  */
988 struct iwl_link_quality_cmd {
989         u8 sta_id;
990         u8 reserved1;
991         __le16 control;
992         struct iwl_link_qual_general_params general_params;
993         struct iwl_link_qual_agg_params agg_params;
994         struct {
995                 __le32 rate_n_flags;
996         } rs_table[LINK_QUAL_MAX_RETRY_NUM];
997         __le32 reserved2;
998 } __attribute__ ((packed));
999 #endif
1000
1001 /*
1002  * REPLY_BT_CONFIG = 0x9b (command, has simple generic response)
1003  */
1004 struct iwl_bt_cmd {
1005         u8 flags;
1006         u8 lead_time;
1007         u8 max_kill;
1008         u8 reserved;
1009         __le32 kill_ack_mask;
1010         __le32 kill_cts_mask;
1011 } __attribute__ ((packed));
1012
1013 /******************************************************************************
1014  * (6)
1015  * Spectrum Management (802.11h) Commands, Responses, Notifications:
1016  *
1017  *****************************************************************************/
1018
1019 /*
1020  * Spectrum Management
1021  */
1022 #define MEASUREMENT_FILTER_FLAG (RXON_FILTER_PROMISC_MSK         | \
1023                                  RXON_FILTER_CTL2HOST_MSK        | \
1024                                  RXON_FILTER_ACCEPT_GRP_MSK      | \
1025                                  RXON_FILTER_DIS_DECRYPT_MSK     | \
1026                                  RXON_FILTER_DIS_GRP_DECRYPT_MSK | \
1027                                  RXON_FILTER_ASSOC_MSK           | \
1028                                  RXON_FILTER_BCON_AWARE_MSK)
1029
1030 struct iwl_measure_channel {
1031         __le32 duration;        /* measurement duration in extended beacon
1032                                  * format */
1033         u8 channel;             /* channel to measure */
1034         u8 type;                /* see enum iwl_measure_type */
1035         __le16 reserved;
1036 } __attribute__ ((packed));
1037
1038 /*
1039  * REPLY_SPECTRUM_MEASUREMENT_CMD = 0x74 (command)
1040  */
1041 struct iwl_spectrum_cmd {
1042         __le16 len;             /* number of bytes starting from token */
1043         u8 token;               /* token id */
1044         u8 id;                  /* measurement id -- 0 or 1 */
1045         u8 origin;              /* 0 = TGh, 1 = other, 2 = TGk */
1046         u8 periodic;            /* 1 = periodic */
1047         __le16 path_loss_timeout;
1048         __le32 start_time;      /* start time in extended beacon format */
1049         __le32 reserved2;
1050         __le32 flags;           /* rxon flags */
1051         __le32 filter_flags;    /* rxon filter flags */
1052         __le16 channel_count;   /* minimum 1, maximum 10 */
1053         __le16 reserved3;
1054         struct iwl_measure_channel channels[10];
1055 } __attribute__ ((packed));
1056
1057 /*
1058  * REPLY_SPECTRUM_MEASUREMENT_CMD = 0x74 (response)
1059  */
1060 struct iwl_spectrum_resp {
1061         u8 token;
1062         u8 id;                  /* id of the prior command replaced, or 0xff */
1063         __le16 status;          /* 0 - command will be handled
1064                                  * 1 - cannot handle (conflicts with another
1065                                  *     measurement) */
1066 } __attribute__ ((packed));
1067
1068 enum iwl_measurement_state {
1069         IWL_MEASUREMENT_START = 0,
1070         IWL_MEASUREMENT_STOP = 1,
1071 };
1072
1073 enum iwl_measurement_status {
1074         IWL_MEASUREMENT_OK = 0,
1075         IWL_MEASUREMENT_CONCURRENT = 1,
1076         IWL_MEASUREMENT_CSA_CONFLICT = 2,
1077         IWL_MEASUREMENT_TGH_CONFLICT = 3,
1078         /* 4-5 reserved */
1079         IWL_MEASUREMENT_STOPPED = 6,
1080         IWL_MEASUREMENT_TIMEOUT = 7,
1081         IWL_MEASUREMENT_PERIODIC_FAILED = 8,
1082 };
1083
1084 #define NUM_ELEMENTS_IN_HISTOGRAM 8
1085
1086 struct iwl_measurement_histogram {
1087         __le32 ofdm[NUM_ELEMENTS_IN_HISTOGRAM]; /* in 0.8usec counts */
1088         __le32 cck[NUM_ELEMENTS_IN_HISTOGRAM];  /* in 1usec counts */
1089 } __attribute__ ((packed));
1090
1091 /* clear channel availability counters */
1092 struct iwl_measurement_cca_counters {
1093         __le32 ofdm;
1094         __le32 cck;
1095 } __attribute__ ((packed));
1096
1097 enum iwl_measure_type {
1098         IWL_MEASURE_BASIC = (1 << 0),
1099         IWL_MEASURE_CHANNEL_LOAD = (1 << 1),
1100         IWL_MEASURE_HISTOGRAM_RPI = (1 << 2),
1101         IWL_MEASURE_HISTOGRAM_NOISE = (1 << 3),
1102         IWL_MEASURE_FRAME = (1 << 4),
1103         /* bits 5:6 are reserved */
1104         IWL_MEASURE_IDLE = (1 << 7),
1105 };
1106
1107 /*
1108  * SPECTRUM_MEASURE_NOTIFICATION = 0x75 (notification only, not a command)
1109  */
1110 struct iwl_spectrum_notification {
1111         u8 id;                  /* measurement id -- 0 or 1 */
1112         u8 token;
1113         u8 channel_index;       /* index in measurement channel list */
1114         u8 state;               /* 0 - start, 1 - stop */
1115         __le32 start_time;      /* lower 32-bits of TSF */
1116         u8 band;                /* 0 - 5.2GHz, 1 - 2.4GHz */
1117         u8 channel;
1118         u8 type;                /* see enum iwl_measurement_type */
1119         u8 reserved1;
1120         /* NOTE:  cca_ofdm, cca_cck, basic_type, and histogram are only only
1121          * valid if applicable for measurement type requested. */
1122         __le32 cca_ofdm;        /* cca fraction time in 40Mhz clock periods */
1123         __le32 cca_cck;         /* cca fraction time in 44Mhz clock periods */
1124         __le32 cca_time;        /* channel load time in usecs */
1125         u8 basic_type;          /* 0 - bss, 1 - ofdm preamble, 2 -
1126                                  * unidentified */
1127         u8 reserved2[3];
1128         struct iwl_measurement_histogram histogram;
1129         __le32 stop_time;       /* lower 32-bits of TSF */
1130         __le32 status;          /* see iwl_measurement_status */
1131 } __attribute__ ((packed));
1132
1133 /******************************************************************************
1134  * (7)
1135  * Power Management Commands, Responses, Notifications:
1136  *
1137  *****************************************************************************/
1138
1139 /**
1140  * struct iwl_powertable_cmd - Power Table Command
1141  * @flags: See below:
1142  *
1143  * POWER_TABLE_CMD = 0x77 (command, has simple generic response)
1144  *
1145  * PM allow:
1146  *   bit 0 - '0' Driver not allow power management
1147  *           '1' Driver allow PM (use rest of parameters)
1148  * uCode send sleep notifications:
1149  *   bit 1 - '0' Don't send sleep notification
1150  *           '1' send sleep notification (SEND_PM_NOTIFICATION)
1151  * Sleep over DTIM
1152  *   bit 2 - '0' PM have to walk up every DTIM
1153  *           '1' PM could sleep over DTIM till listen Interval.
1154  * PCI power managed
1155  *   bit 3 - '0' (PCI_LINK_CTRL & 0x1)
1156  *           '1' !(PCI_LINK_CTRL & 0x1)
1157  * Force sleep Modes
1158  *   bit 31/30- '00' use both mac/xtal sleeps
1159  *              '01' force Mac sleep
1160  *              '10' force xtal sleep
1161  *              '11' Illegal set
1162  *
1163  * NOTE: if sleep_interval[SLEEP_INTRVL_TABLE_SIZE-1] > DTIM period then
1164  * ucode assume sleep over DTIM is allowed and we don't need to wakeup
1165  * for every DTIM.
1166  */
1167 #define IWL_POWER_VEC_SIZE 5
1168
1169
1170 #if IWL == 3945
1171
1172 #define IWL_POWER_DRIVER_ALLOW_SLEEP_MSK        __constant_cpu_to_le32(1<<0)
1173 #define IWL_POWER_SLEEP_OVER_DTIM_MSK           __constant_cpu_to_le32(1<<2)
1174 #define IWL_POWER_PCI_PM_MSK                    __constant_cpu_to_le32(1<<3)
1175 struct iwl_powertable_cmd {
1176         __le32 flags;
1177         __le32 rx_data_timeout;
1178         __le32 tx_data_timeout;
1179         __le32 sleep_interval[IWL_POWER_VEC_SIZE];
1180 } __attribute__((packed));
1181
1182 #elif IWL == 4965
1183
1184 #define IWL_POWER_DRIVER_ALLOW_SLEEP_MSK        __constant_cpu_to_le16(1<<0)
1185 #define IWL_POWER_SLEEP_OVER_DTIM_MSK           __constant_cpu_to_le16(1<<2)
1186 #define IWL_POWER_PCI_PM_MSK                    __constant_cpu_to_le16(1<<3)
1187
1188 struct iwl_powertable_cmd {
1189         __le16 flags;
1190         u8 keep_alive_seconds;
1191         u8 debug_flags;
1192         __le32 rx_data_timeout;
1193         __le32 tx_data_timeout;
1194         __le32 sleep_interval[IWL_POWER_VEC_SIZE];
1195         __le32 keep_alive_beacons;
1196 } __attribute__ ((packed));
1197 #endif
1198
1199 /*
1200  * PM_SLEEP_NOTIFICATION = 0x7A (notification only, not a command)
1201  * 3945 and 4965 identical.
1202  */
1203 struct iwl_sleep_notification {
1204         u8 pm_sleep_mode;
1205         u8 pm_wakeup_src;
1206         __le16 reserved;
1207         __le32 sleep_time;
1208         __le32 tsf_low;
1209         __le32 bcon_timer;
1210 } __attribute__ ((packed));
1211
1212 /* Sleep states.  3945 and 4965 identical. */
1213 enum {
1214         IWL_PM_NO_SLEEP = 0,
1215         IWL_PM_SLP_MAC = 1,
1216         IWL_PM_SLP_FULL_MAC_UNASSOCIATE = 2,
1217         IWL_PM_SLP_FULL_MAC_CARD_STATE = 3,
1218         IWL_PM_SLP_PHY = 4,
1219         IWL_PM_SLP_REPENT = 5,
1220         IWL_PM_WAKEUP_BY_TIMER = 6,
1221         IWL_PM_WAKEUP_BY_DRIVER = 7,
1222         IWL_PM_WAKEUP_BY_RFKILL = 8,
1223         /* 3 reserved */
1224         IWL_PM_NUM_OF_MODES = 12,
1225 };
1226
1227 /*
1228  * REPLY_CARD_STATE_CMD = 0xa0 (command, has simple generic response)
1229  */
1230 #define CARD_STATE_CMD_DISABLE 0x00     /* Put card to sleep */
1231 #define CARD_STATE_CMD_ENABLE  0x01     /* Wake up card */
1232 #define CARD_STATE_CMD_HALT    0x02     /* Power down permanently */
1233 struct iwl_card_state_cmd {
1234         __le32 status;          /* CARD_STATE_CMD_* request new power state */
1235 } __attribute__ ((packed));
1236
1237 /*
1238  * CARD_STATE_NOTIFICATION = 0xa1 (notification only, not a command)
1239  */
1240 struct iwl_card_state_notif {
1241         __le32 flags;
1242 } __attribute__ ((packed));
1243
1244 #define HW_CARD_DISABLED   0x01
1245 #define SW_CARD_DISABLED   0x02
1246 #define RF_CARD_DISABLED   0x04
1247 #define RXON_CARD_DISABLED 0x10
1248
1249 struct iwl_ct_kill_config {
1250         __le32   reserved;
1251         __le32   critical_temperature_M;
1252         __le32   critical_temperature_R;
1253 }  __attribute__ ((packed));
1254
1255 /******************************************************************************
1256  * (8)
1257  * Scan Commands, Responses, Notifications:
1258  *
1259  *****************************************************************************/
1260
1261 struct iwl_scan_channel {
1262         /* type is defined as:
1263          * 0:0 active (0 - passive)
1264          * 1:4 SSID direct
1265          *     If 1 is set then corresponding SSID IE is transmitted in probe
1266          * 5:7 reserved
1267          */
1268         u8 type;
1269         u8 channel;
1270         struct iwl_tx_power tpc;
1271         __le16 active_dwell;
1272         __le16 passive_dwell;
1273 } __attribute__ ((packed));
1274
1275 struct iwl_ssid_ie {
1276         u8 id;
1277         u8 len;
1278         u8 ssid[32];
1279 } __attribute__ ((packed));
1280
1281 #define PROBE_OPTION_MAX        0x4
1282 #define TX_CMD_LIFE_TIME_INFINITE       __constant_cpu_to_le32(0xFFFFFFFF)
1283 #define IWL_GOOD_CRC_TH         __constant_cpu_to_le16(1)
1284 #define IWL_MAX_SCAN_SIZE 1024
1285
1286 /*
1287  * REPLY_SCAN_CMD = 0x80 (command)
1288  */
1289 struct iwl_scan_cmd {
1290         __le16 len;
1291         u8 reserved0;
1292         u8 channel_count;
1293         __le16 quiet_time;     /* dwell only this long on quiet chnl
1294                                 * (active scan) */
1295         __le16 quiet_plcp_th;  /* quiet chnl is < this # pkts (typ. 1) */
1296         __le16 good_CRC_th;    /* passive -> active promotion threshold */
1297 #if IWL == 3945
1298         __le16 reserved1;
1299 #elif IWL == 4965
1300         __le16 rx_chain;
1301 #endif
1302         __le32 max_out_time;   /* max usec to be out of associated (service)
1303                                 * chnl */
1304         __le32 suspend_time;   /* pause scan this long when returning to svc
1305                                 * chnl.
1306                                 * 3945 -- 31:24 # beacons, 19:0 additional usec,
1307                                 * 4965 -- 31:22 # beacons, 21:0 additional usec.
1308                                 */
1309         __le32 flags;
1310         __le32 filter_flags;
1311
1312         struct iwl_tx_cmd tx_cmd;
1313         struct iwl_ssid_ie direct_scan[PROBE_OPTION_MAX];
1314
1315         u8 data[0];
1316         /*
1317          * The channels start after the probe request payload and are of type:
1318          *
1319          * struct iwl_scan_channel channels[0];
1320          *
1321          * NOTE:  Only one band of channels can be scanned per pass.  You
1322          * can not mix 2.4GHz channels and 5.2GHz channels and must
1323          * request a scan multiple times (not concurrently)
1324          *
1325          */
1326 } __attribute__ ((packed));
1327
1328 /* Can abort will notify by complete notification with abort status. */
1329 #define CAN_ABORT_STATUS        __constant_cpu_to_le32(0x1)
1330 /* complete notification statuses */
1331 #define ABORT_STATUS            0x2
1332
1333 /*
1334  * REPLY_SCAN_CMD = 0x80 (response)
1335  */
1336 struct iwl_scanreq_notification {
1337         __le32 status;          /* 1: okay, 2: cannot fulfill request */
1338 } __attribute__ ((packed));
1339
1340 /*
1341  * SCAN_START_NOTIFICATION = 0x82 (notification only, not a command)
1342  */
1343 struct iwl_scanstart_notification {
1344         __le32 tsf_low;
1345         __le32 tsf_high;
1346         __le32 beacon_timer;
1347         u8 channel;
1348         u8 band;
1349         u8 reserved[2];
1350         __le32 status;
1351 } __attribute__ ((packed));
1352
1353 #define  SCAN_OWNER_STATUS 0x1;
1354 #define  MEASURE_OWNER_STATUS 0x2;
1355
1356 #define NUMBER_OF_STATISTICS 1  /* first __le32 is good CRC */
1357 /*
1358  * SCAN_RESULTS_NOTIFICATION = 0x83 (notification only, not a command)
1359  */
1360 struct iwl_scanresults_notification {
1361         u8 channel;
1362         u8 band;
1363         u8 reserved[2];
1364         __le32 tsf_low;
1365         __le32 tsf_high;
1366         __le32 statistics[NUMBER_OF_STATISTICS];
1367 } __attribute__ ((packed));
1368
1369 /*
1370  * SCAN_COMPLETE_NOTIFICATION = 0x84 (notification only, not a command)
1371  */
1372 struct iwl_scancomplete_notification {
1373         u8 scanned_channels;
1374         u8 status;
1375         u8 reserved;
1376         u8 last_channel;
1377         __le32 tsf_low;
1378         __le32 tsf_high;
1379 } __attribute__ ((packed));
1380
1381
1382 /******************************************************************************
1383  * (9)
1384  * IBSS/AP Commands and Notifications:
1385  *
1386  *****************************************************************************/
1387
1388 /*
1389  * BEACON_NOTIFICATION = 0x90 (notification only, not a command)
1390  */
1391 struct iwl_beacon_notif {
1392         struct iwl_tx_resp beacon_notify_hdr;
1393         __le32 low_tsf;
1394         __le32 high_tsf;
1395         __le32 ibss_mgr_status;
1396 } __attribute__ ((packed));
1397
1398 /*
1399  * REPLY_TX_BEACON = 0x91 (command, has simple generic response)
1400  */
1401 struct iwl_tx_beacon_cmd {
1402         struct iwl_tx_cmd tx;
1403         __le16 tim_idx;
1404         u8 tim_size;
1405         u8 reserved1;
1406         struct ieee80211_hdr frame[0];  /* beacon frame */
1407 } __attribute__ ((packed));
1408
1409 /******************************************************************************
1410  * (10)
1411  * Statistics Commands and Notifications:
1412  *
1413  *****************************************************************************/
1414
1415 #define IWL_TEMP_CONVERT 260
1416
1417 #define SUP_RATE_11A_MAX_NUM_CHANNELS  8
1418 #define SUP_RATE_11B_MAX_NUM_CHANNELS  4
1419 #define SUP_RATE_11G_MAX_NUM_CHANNELS  12
1420
1421 /* Used for passing to driver number of successes and failures per rate */
1422 struct rate_histogram {
1423         union {
1424                 __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
1425                 __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
1426                 __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
1427         } success;
1428         union {
1429                 __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
1430                 __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
1431                 __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
1432         } failed;
1433 } __attribute__ ((packed));
1434
1435 /* statistics command response */
1436
1437 struct statistics_rx_phy {
1438         __le32 ina_cnt;
1439         __le32 fina_cnt;
1440         __le32 plcp_err;
1441         __le32 crc32_err;
1442         __le32 overrun_err;
1443         __le32 early_overrun_err;
1444         __le32 crc32_good;
1445         __le32 false_alarm_cnt;
1446         __le32 fina_sync_err_cnt;
1447         __le32 sfd_timeout;
1448         __le32 fina_timeout;
1449         __le32 unresponded_rts;
1450         __le32 rxe_frame_limit_overrun;
1451         __le32 sent_ack_cnt;
1452         __le32 sent_cts_cnt;
1453 #if IWL == 4965
1454         __le32 sent_ba_rsp_cnt;
1455         __le32 dsp_self_kill;
1456         __le32 mh_format_err;
1457         __le32 re_acq_main_rssi_sum;
1458         __le32 reserved3;
1459 #endif
1460 } __attribute__ ((packed));
1461
1462 #if IWL == 4965
1463 struct statistics_rx_ht_phy {
1464         __le32 plcp_err;
1465         __le32 overrun_err;
1466         __le32 early_overrun_err;
1467         __le32 crc32_good;
1468         __le32 crc32_err;
1469         __le32 mh_format_err;
1470         __le32 agg_crc32_good;
1471         __le32 agg_mpdu_cnt;
1472         __le32 agg_cnt;
1473         __le32 reserved2;
1474 } __attribute__ ((packed));
1475 #endif
1476
1477 struct statistics_rx_non_phy {
1478         __le32 bogus_cts;       /* CTS received when not expecting CTS */
1479         __le32 bogus_ack;       /* ACK received when not expecting ACK */
1480         __le32 non_bssid_frames;        /* number of frames with BSSID that
1481                                          * doesn't belong to the STA BSSID */
1482         __le32 filtered_frames; /* count frames that were dumped in the
1483                                  * filtering process */
1484         __le32 non_channel_beacons;     /* beacons with our bss id but not on
1485                                          * our serving channel */
1486 #if IWL == 4965
1487         __le32 channel_beacons; /* beacons with our bss id and in our
1488                                  * serving channel */
1489         __le32 num_missed_bcon; /* number of missed beacons */
1490         __le32 adc_rx_saturation_time;  /* count in 0.8us units the time the
1491                                          * ADC was in saturation */
1492         __le32 ina_detection_search_time;/* total time (in 0.8us) searched
1493                                           * for INA */
1494         __le32 beacon_silence_rssi_a;   /* RSSI silence after beacon frame */
1495         __le32 beacon_silence_rssi_b;   /* RSSI silence after beacon frame */
1496         __le32 beacon_silence_rssi_c;   /* RSSI silence after beacon frame */
1497         __le32 interference_data_flag;  /* flag for interference data
1498                                          * availability. 1 when data is
1499                                          * available. */
1500         __le32 channel_load;    /* counts RX Enable time */
1501         __le32 dsp_false_alarms;        /* DSP false alarm (both OFDM
1502                                          * and CCK) counter */
1503         __le32 beacon_rssi_a;
1504         __le32 beacon_rssi_b;
1505         __le32 beacon_rssi_c;
1506         __le32 beacon_energy_a;
1507         __le32 beacon_energy_b;
1508         __le32 beacon_energy_c;
1509 #endif
1510 } __attribute__ ((packed));
1511
1512 struct statistics_rx {
1513         struct statistics_rx_phy ofdm;
1514         struct statistics_rx_phy cck;
1515         struct statistics_rx_non_phy general;
1516 #if IWL == 4965
1517         struct statistics_rx_ht_phy ofdm_ht;
1518 #endif
1519 } __attribute__ ((packed));
1520
1521 #if IWL == 4965
1522 struct statistics_tx_non_phy_agg {
1523         __le32 ba_timeout;
1524         __le32 ba_reschedule_frames;
1525         __le32 scd_query_agg_frame_cnt;
1526         __le32 scd_query_no_agg;
1527         __le32 scd_query_agg;
1528         __le32 scd_query_mismatch;
1529         __le32 frame_not_ready;
1530         __le32 underrun;
1531         __le32 bt_prio_kill;
1532         __le32 rx_ba_rsp_cnt;
1533         __le32 reserved2;
1534         __le32 reserved3;
1535 } __attribute__ ((packed));
1536 #endif
1537
1538 struct statistics_tx {
1539         __le32 preamble_cnt;
1540         __le32 rx_detected_cnt;
1541         __le32 bt_prio_defer_cnt;
1542         __le32 bt_prio_kill_cnt;
1543         __le32 few_bytes_cnt;
1544         __le32 cts_timeout;
1545         __le32 ack_timeout;
1546         __le32 expected_ack_cnt;
1547         __le32 actual_ack_cnt;
1548 #if IWL == 4965
1549         __le32 dump_msdu_cnt;
1550         __le32 burst_abort_next_frame_mismatch_cnt;
1551         __le32 burst_abort_missing_next_frame_cnt;
1552         __le32 cts_timeout_collision;
1553         __le32 ack_or_ba_timeout_collision;
1554         struct statistics_tx_non_phy_agg agg;
1555 #endif
1556 } __attribute__ ((packed));
1557
1558 struct statistics_dbg {
1559         __le32 burst_check;
1560         __le32 burst_count;
1561         __le32 reserved[4];
1562 } __attribute__ ((packed));
1563
1564 struct statistics_div {
1565         __le32 tx_on_a;
1566         __le32 tx_on_b;
1567         __le32 exec_time;
1568         __le32 probe_time;
1569 #if IWL == 4965
1570         __le32 reserved1;
1571         __le32 reserved2;
1572 #endif
1573 } __attribute__ ((packed));
1574
1575 struct statistics_general {
1576         __le32 temperature;
1577 #if IWL == 4965
1578         __le32 temperature_m;
1579 #endif
1580         struct statistics_dbg dbg;
1581         __le32 sleep_time;
1582         __le32 slots_out;
1583         __le32 slots_idle;
1584         __le32 ttl_timestamp;
1585         struct statistics_div div;
1586 #if IWL == 4965
1587         __le32 rx_enable_counter;
1588         __le32 reserved1;
1589         __le32 reserved2;
1590         __le32 reserved3;
1591 #endif
1592 } __attribute__ ((packed));
1593
1594 /*
1595  * REPLY_STATISTICS_CMD = 0x9c,
1596  * 3945 and 4965 identical.
1597  *
1598  * This command triggers an immediate response containing uCode statistics.
1599  * The response is in the same format as STATISTICS_NOTIFICATION 0x9d, below.
1600  *
1601  * If the CLEAR_STATS configuration flag is set, uCode will clear its
1602  * internal copy of the statistics (counters) after issuing the response.
1603  * This flag does not affect STATISTICS_NOTIFICATIONs after beacons (see below).
1604  *
1605  * If the DISABLE_NOTIF configuration flag is set, uCode will not issue
1606  * STATISTICS_NOTIFICATIONs after received beacons (see below).  This flag
1607  * does not affect the response to the REPLY_STATISTICS_CMD 0x9c itself.
1608  */
1609 #define IWL_STATS_CONF_CLEAR_STATS __constant_cpu_to_le32(0x1)  /* see above */
1610 #define IWL_STATS_CONF_DISABLE_NOTIF __constant_cpu_to_le32(0x2)/* see above */
1611 struct iwl_statistics_cmd {
1612         __le32 configuration_flags;     /* IWL_STATS_CONF_* */
1613 } __attribute__ ((packed));
1614
1615 /*
1616  * STATISTICS_NOTIFICATION = 0x9d (notification only, not a command)
1617  *
1618  * By default, uCode issues this notification after receiving a beacon
1619  * while associated.  To disable this behavior, set DISABLE_NOTIF flag in the
1620  * REPLY_STATISTICS_CMD 0x9c, above.
1621  *
1622  * Statistics counters continue to increment beacon after beacon, but are
1623  * cleared when changing channels or when driver issues REPLY_STATISTICS_CMD
1624  * 0x9c with CLEAR_STATS bit set (see above).
1625  *
1626  * uCode also issues this notification during scans.  uCode clears statistics
1627  * appropriately so that each notification contains statistics for only the
1628  * one channel that has just been scanned.
1629  */
1630 #define STATISTICS_REPLY_FLG_BAND_24G_MSK         __constant_cpu_to_le32(0x2)
1631 #define STATISTICS_REPLY_FLG_FAT_MODE_MSK         __constant_cpu_to_le32(0x8)
1632 struct iwl_notif_statistics {
1633         __le32 flag;
1634         struct statistics_rx rx;
1635         struct statistics_tx tx;
1636         struct statistics_general general;
1637 } __attribute__ ((packed));
1638
1639
1640 /*
1641  * MISSED_BEACONS_NOTIFICATION = 0xa2 (notification only, not a command)
1642  */
1643 /* if ucode missed CONSECUTIVE_MISSED_BCONS_TH beacons in a row,
1644  * then this notification will be sent. */
1645 #define CONSECUTIVE_MISSED_BCONS_TH 20
1646
1647 struct iwl_missed_beacon_notif {
1648         __le32 consequtive_missed_beacons;
1649         __le32 total_missed_becons;
1650         __le32 num_expected_beacons;
1651         __le32 num_recvd_beacons;
1652 } __attribute__ ((packed));
1653
1654 /******************************************************************************
1655  * (11)
1656  * Rx Calibration Commands:
1657  *
1658  *****************************************************************************/
1659
1660 #define PHY_CALIBRATE_DIFF_GAIN_CMD (7)
1661 #define HD_TABLE_SIZE  (11)
1662
1663 struct iwl_sensitivity_cmd {
1664         __le16 control;
1665         __le16 table[HD_TABLE_SIZE];
1666 } __attribute__ ((packed));
1667
1668 struct iwl_calibration_cmd {
1669         u8 opCode;
1670         u8 flags;
1671         __le16 reserved;
1672         s8 diff_gain_a;
1673         s8 diff_gain_b;
1674         s8 diff_gain_c;
1675         u8 reserved1;
1676 } __attribute__ ((packed));
1677
1678 /******************************************************************************
1679  * (12)
1680  * Miscellaneous Commands:
1681  *
1682  *****************************************************************************/
1683
1684 /*
1685  * LEDs Command & Response
1686  * REPLY_LEDS_CMD = 0x48 (command, has simple generic response)
1687  *
1688  * For each of 3 possible LEDs (Activity/Link/Tech, selected by "id" field),
1689  * this command turns it on or off, or sets up a periodic blinking cycle.
1690  */
1691 struct iwl_led_cmd {
1692         __le32 interval;        /* "interval" in uSec */
1693         u8 id;                  /* 1: Activity, 2: Link, 3: Tech */
1694         u8 off;                 /* # intervals off while blinking;
1695                                  * "0", with >0 "on" value, turns LED on */
1696         u8 on;                  /* # intervals on while blinking;
1697                                  * "0", regardless of "off", turns LED off */
1698         u8 reserved;
1699 } __attribute__ ((packed));
1700
1701 /******************************************************************************
1702  * (13)
1703  * Union of all expected notifications/responses:
1704  *
1705  *****************************************************************************/
1706
1707 struct iwl_rx_packet {
1708         __le32 len;
1709         struct iwl_cmd_header hdr;
1710         union {
1711                 struct iwl_alive_resp alive_frame;
1712                 struct iwl_rx_frame rx_frame;
1713                 struct iwl_tx_resp tx_resp;
1714                 struct iwl_spectrum_notification spectrum_notif;
1715                 struct iwl_csa_notification csa_notif;
1716                 struct iwl_error_resp err_resp;
1717                 struct iwl_card_state_notif card_state_notif;
1718                 struct iwl_beacon_notif beacon_status;
1719                 struct iwl_add_sta_resp add_sta;
1720                 struct iwl_sleep_notification sleep_notif;
1721                 struct iwl_spectrum_resp spectrum;
1722                 struct iwl_notif_statistics stats;
1723 #if IWL == 4965
1724                 struct iwl_compressed_ba_resp compressed_ba;
1725                 struct iwl_missed_beacon_notif missed_beacon;
1726 #endif
1727                 __le32 status;
1728                 u8 raw[0];
1729         } u;
1730 } __attribute__ ((packed));
1731
1732 #define IWL_RX_FRAME_SIZE        (4 + sizeof(struct iwl_rx_frame))
1733
1734 #endif                          /* __iwl_commands_h__ */