if_wpi - Port of FreeBSD's wpi driver for Intel 3945ABG Wifi adapters.
[dragonfly.git] / sys / dev / netif / wpi / if_wpireg.h
1 /*      $FreeBSD: src/sys/dev/wpi/if_wpireg.h,v 1.4.2.1 2009/08/03 08:13:06 kensmith Exp $      */
2
3 /*-
4  * Copyright (c) 2006,2007
5  *      Damien Bergamini <damien.bergamini@free.fr>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19
20 #define WPI_TX_RING_COUNT       256
21 #define WPI_CMD_RING_COUNT      256
22 #define WPI_RX_RING_COUNT       64
23
24 /*
25  * Rings must be aligned on a 16K boundary.
26  */
27 #define WPI_RING_DMA_ALIGN      0x4000
28
29 /* maximum scatter/gather */
30 #define WPI_MAX_SCATTER 4
31
32 /* maximum Rx buffer size */
33 #define WPI_RBUF_SIZE ( 3 * 1024 ) /* XXX 3000 but must be aligned */
34
35 /*
36  * Control and status registers.
37  */
38 #define WPI_HWCONFIG            0x000
39 #define WPI_INTR                0x008
40 #define WPI_MASK                0x00c
41 #define WPI_INTR_STATUS         0x010
42 #define WPI_GPIO_STATUS         0x018
43 #define WPI_RESET               0x020
44 #define WPI_GPIO_CTL            0x024
45 #define WPI_EEPROM_CTL          0x02c
46 #define WPI_EEPROM_STATUS       0x030
47 #define WPI_UCODE_SET           0x058
48 #define WPI_UCODE_CLR           0x05c
49 #define WPI_TEMPERATURE         0x060
50 #define WPI_CHICKEN             0x100
51 #define WPI_PLL_CTL             0x20c
52 #define WPI_WRITE_MEM_ADDR      0x444
53 #define WPI_READ_MEM_ADDR       0x448
54 #define WPI_WRITE_MEM_DATA      0x44c
55 #define WPI_READ_MEM_DATA       0x450
56 #define WPI_TX_WIDX             0x460
57 #define WPI_TX_CTL(qid)         (0x940 + (qid) * 8)
58 #define WPI_TX_BASE(qid)        (0x944 + (qid) * 8)
59 #define WPI_TX_DESC(qid)        (0x980 + (qid) * 80)
60 #define WPI_RX_CONFIG           0xc00
61 #define WPI_RX_BASE             0xc04
62 #define WPI_RX_WIDX             0xc20
63 #define WPI_RX_RIDX_PTR         0xc24
64 #define WPI_RX_CTL              0xcc0
65 #define WPI_RX_STATUS           0xcc4
66 #define WPI_TX_CONFIG(qid)      (0xd00 + (qid) * 32)
67 #define WPI_TX_CREDIT(qid)      (0xd04 + (qid) * 32)
68 #define WPI_TX_STATE(qid)       (0xd08 + (qid) * 32)
69 #define WPI_TX_BASE_PTR         0xe80
70 #define WPI_MSG_CONFIG          0xe88
71 #define WPI_TX_STATUS           0xe90
72
73
74 /*
75  * NIC internal memory offsets.
76  */
77 #define WPI_MEM_MODE            0x2e00
78 #define WPI_MEM_RA              0x2e04
79 #define WPI_MEM_TXCFG           0x2e10
80 #define WPI_MEM_MAGIC4          0x2e14
81 #define WPI_MEM_MAGIC5          0x2e20
82 #define WPI_MEM_BYPASS1         0x2e2c
83 #define WPI_MEM_BYPASS2         0x2e30
84 #define WPI_MEM_CLOCK1          0x3004
85 #define WPI_MEM_CLOCK2          0x3008
86 #define WPI_MEM_POWER           0x300c
87 #define WPI_MEM_PCIDEV          0x3010
88 #define WPI_MEM_HW_RADIO_OFF    0x3014
89 #define WPI_MEM_UCODE_CTL       0x3400
90 #define WPI_MEM_UCODE_SRC       0x3404
91 #define WPI_MEM_UCODE_DST       0x3408
92 #define WPI_MEM_UCODE_SIZE      0x340c
93 #define WPI_MEM_UCODE_BASE      0x3800
94
95 #define WPI_MEM_TEXT_BASE       0x3490
96 #define WPI_MEM_TEXT_SIZE       0x3494
97 #define WPI_MEM_DATA_BASE       0x3498
98 #define WPI_MEM_DATA_SIZE       0x349c
99
100
101 /* possible flags for register WPI_HWCONFIG */
102 #define WPI_HW_ALM_MB   (1 << 8)
103 #define WPI_HW_ALM_MM   (1 << 9)
104 #define WPI_HW_SKU_MRC  (1 << 10)
105 #define WPI_HW_REV_D    (1 << 11)
106 #define WPI_HW_TYPE_B   (1 << 12)
107
108 /* possible flags for registers WPI_READ_MEM_ADDR/WPI_WRITE_MEM_ADDR */
109 #define WPI_MEM_4       ((sizeof (uint32_t) - 1) << 24)
110
111 /* possible values for WPI_MEM_UCODE_DST */
112 #define WPI_FW_TEXT     0x00000000
113
114 /* possible flags for WPI_GPIO_STATUS */
115 #define WPI_POWERED             (1 << 9)
116
117 /* possible flags for register WPI_RESET */
118 #define WPI_NEVO_RESET          (1 << 0)
119 #define WPI_SW_RESET            (1 << 7)
120 #define WPI_MASTER_DISABLED     (1 << 8)
121 #define WPI_STOP_MASTER         (1 << 9)
122
123 /* possible flags for register WPI_GPIO_CTL */
124 #define WPI_GPIO_CLOCK          (1 << 0)
125 #define WPI_GPIO_INIT           (1 << 2)
126 #define WPI_GPIO_MAC            (1 << 3)
127 #define WPI_GPIO_SLEEP          (1 << 4)
128 #define WPI_GPIO_PWR_STATUS     0x07000000
129 #define WPI_GPIO_PWR_SLEEP      (4 << 24)
130
131 /* possible flags for register WPI_CHICKEN */
132 #define WPI_CHICKEN_RXNOLOS     (1 << 23)
133
134 /* possible flags for register WPI_PLL_CTL */
135 #define WPI_PLL_INIT            (1 << 24)
136
137 /* possible flags for register WPI_UCODE_CLR */
138 #define WPI_RADIO_OFF           (1 << 1)
139 #define WPI_DISABLE_CMD         (1 << 2)
140
141 /* possible flags for WPI_RX_STATUS */
142 #define WPI_RX_IDLE     (1 << 24)
143
144 /* possible flags for register WPI_UC_CTL */
145 #define WPI_UC_ENABLE   (1 << 30)
146 #define WPI_UC_RUN      (1 << 31)
147
148 /* possible flags for register WPI_INTR_CSR */
149 #define WPI_ALIVE_INTR  (1 << 0)
150 #define WPI_WAKEUP_INTR (1 << 1)
151 #define WPI_SW_ERROR    (1 << 25)
152 #define WPI_TX_INTR     (1 << 27)
153 #define WPI_HW_ERROR    (1 << 29)
154 #define WPI_RX_INTR     (1 << 31)
155
156 #define WPI_INTR_MASK                                                   \
157         (WPI_SW_ERROR | WPI_HW_ERROR | WPI_TX_INTR | WPI_RX_INTR |      \
158          WPI_ALIVE_INTR | WPI_WAKEUP_INTR)
159
160 /* possible flags for register WPI_TX_STATUS */
161 #define WPI_TX_IDLE(qid)        (1 << ((qid) + 24) | 1 << ((qid) + 16))
162
163 /* possible flags for register WPI_EEPROM_CTL */
164 #define WPI_EEPROM_READY        (1 << 0)
165
166 /* possible flags for register WPI_EEPROM_STATUS */
167 #define WPI_EEPROM_VERSION      0x00000007
168 #define WPI_EEPROM_LOCKED       0x00000180
169
170
171 struct wpi_shared {
172         uint32_t        txbase[8];
173         uint32_t        next;
174         uint32_t        reserved[2];
175 } __packed;
176
177 #define WPI_MAX_SEG_LEN 65520
178 struct wpi_tx_desc {
179         uint32_t        flags;
180 #define WPI_PAD32(x)    (roundup2(x, 4) - (x))
181
182         struct {
183                 uint32_t        addr;
184                 uint32_t        len;
185         } __attribute__((__packed__))   segs[WPI_MAX_SCATTER];
186         uint8_t         reserved[28];
187 } __packed;
188
189 struct wpi_tx_stat {
190         uint8_t         nrts;
191         uint8_t         ntries;
192         uint8_t         nkill;
193         uint8_t         rate;
194         uint32_t        duration;
195         uint32_t        status;
196 } __packed;
197
198 struct wpi_rx_desc {
199         uint32_t        len;
200         uint8_t         type;
201 #define WPI_UC_READY              1
202 #define WPI_RX_DONE              27
203 #define WPI_TX_DONE              28
204 #define WPI_START_SCAN          130
205 #define WPI_SCAN_RESULTS        131
206 #define WPI_STOP_SCAN           132
207 #define WPI_STATE_CHANGED       161
208 #define WPI_MISSED_BEACON       162
209
210         uint8_t         flags;
211         uint8_t         idx;
212         uint8_t         qid;
213 } __packed;
214
215 struct wpi_rx_stat {
216         uint8_t         len;
217 #define WPI_STAT_MAXLEN 20
218
219         uint8_t         id;
220         uint8_t         rssi;   /* received signal strength */
221 #define WPI_RSSI_OFFSET 95
222
223         uint8_t         agc;    /* access gain control */
224         uint16_t        signal;
225         uint16_t        noise;
226 } __packed;
227
228 struct wpi_rx_head {
229         uint16_t        chan;
230         uint16_t        flags;
231         uint8_t         reserved;
232         uint8_t         rate;
233         uint16_t        len;
234 } __packed;
235
236 struct wpi_rx_tail {
237         uint32_t        flags;
238 #define WPI_RX_NO_CRC_ERR       (1 << 0)
239 #define WPI_RX_NO_OVFL_ERR      (1 << 1)
240 /* shortcut for the above */
241 #define WPI_RX_NOERROR          (WPI_RX_NO_CRC_ERR | WPI_RX_NO_OVFL_ERR)
242         uint64_t        tstamp;
243         uint32_t        tbeacon;
244 } __packed;
245
246 struct wpi_tx_cmd {
247         uint8_t code;
248 #define WPI_CMD_CONFIGURE        16
249 #define WPI_CMD_ASSOCIATE        17
250 #define WPI_CMD_SET_WME          19
251 #define WPI_CMD_TSF              20
252 #define WPI_CMD_ADD_NODE         24
253 #define WPI_CMD_TX_DATA          28
254 #define WPI_CMD_MRR_SETUP        71
255 #define WPI_CMD_SET_LED          72
256 #define WPI_CMD_SET_POWER_MODE  119
257 #define WPI_CMD_SCAN            128
258 #define WPI_CMD_SET_BEACON      145
259 #define WPI_CMD_TXPOWER         151
260 #define WPI_CMD_BLUETOOTH       155
261
262         uint8_t flags;
263         uint8_t idx;
264         uint8_t qid;
265         uint8_t data[360];
266 } __packed;
267
268 /* structure for WPI_CMD_CONFIGURE */
269 struct wpi_config {
270         uint8_t         myaddr[IEEE80211_ADDR_LEN];
271         uint16_t        reserved1;
272         uint8_t         bssid[IEEE80211_ADDR_LEN];
273         uint16_t        reserved2;
274         uint8_t         wlap_bssid_addr[6];
275         uint16_t        reserved3;
276         uint8_t         mode;
277 #define WPI_MODE_HOSTAP         1
278 #define WPI_MODE_STA            3
279 #define WPI_MODE_IBSS           4
280 #define WPI_MODE_MONITOR        6
281
282         uint8_t         air_propogation;
283         uint16_t        reserved4;
284         uint8_t         ofdm_mask;
285         uint8_t         cck_mask;
286         uint16_t        associd;
287         uint32_t        flags;
288 #define WPI_CONFIG_24GHZ        (1 << 0)
289 #define WPI_CONFIG_CCK          (1 << 1)
290 #define WPI_CONFIG_AUTO         (1 << 2)
291 #define WPI_CONFIG_SHSLOT       (1 << 4)
292 #define WPI_CONFIG_SHPREAMBLE   (1 << 5)
293 #define WPI_CONFIG_NODIVERSITY  (1 << 7)
294 #define WPI_CONFIG_ANTENNA_A    (1 << 8)
295 #define WPI_CONFIG_ANTENNA_B    (1 << 9)
296 #define WPI_CONFIG_TSF          (1 << 15)
297
298         uint32_t        filter;
299 #define WPI_FILTER_PROMISC      (1 << 0)
300 #define WPI_FILTER_CTL          (1 << 1)
301 #define WPI_FILTER_MULTICAST    (1 << 2)
302 #define WPI_FILTER_NODECRYPT    (1 << 3)
303 #define WPI_FILTER_BSS          (1 << 5)
304 #define WPI_FILTER_BEACON       (1 << 6)
305
306         uint8_t         chan;
307         uint16_t        reserved6;
308 } __packed;
309
310 /* structure for command WPI_CMD_ASSOCIATE */
311 struct wpi_assoc {
312         uint32_t        flags;
313         uint32_t        filter;
314         uint8_t         ofdm_mask;
315         uint8_t         cck_mask;
316         uint16_t        reserved;
317 } __packed;
318
319 /* structure for command WPI_CMD_SET_WME */
320 struct wpi_wme_setup {
321         uint32_t        flags;
322         struct {
323                 uint16_t        cwmin;
324                 uint16_t        cwmax;
325                 uint8_t         aifsn;
326                 uint8_t         reserved;
327                 uint16_t        txop;
328         } __packed      ac[WME_NUM_AC];
329 } __packed;
330
331 /* structure for command WPI_CMD_TSF */
332 struct wpi_cmd_tsf {
333         uint64_t        tstamp;
334         uint16_t        bintval;
335         uint16_t        atim;
336         uint32_t        binitval;
337         uint16_t        lintval;
338         uint16_t        reserved;
339 } __packed;
340
341 /* structure for WPI_CMD_ADD_NODE */
342 struct wpi_node_info {
343         uint8_t         control;
344 #define WPI_NODE_UPDATE (1 << 0)
345
346         uint8_t         reserved1[3];
347         uint8_t         bssid[IEEE80211_ADDR_LEN];
348         uint16_t        reserved2;
349         uint8_t         id;
350 #define WPI_ID_BSS              0
351 #define WPI_ID_BROADCAST        24
352
353         uint8_t         flags;
354         uint16_t        reserved3;
355         uint16_t        key_flags;
356         uint8_t         tkip;
357         uint8_t         reserved4;
358         uint16_t        ttak[5];
359         uint16_t        reserved5;
360         uint8_t         key[IEEE80211_KEYBUF_SIZE];
361         uint32_t        action;
362 #define WPI_ACTION_SET_RATE     4
363         uint32_t        mask;
364         uint16_t        tid;
365         uint8_t         rate;
366         uint8_t         antenna;
367 #define WPI_ANTENNA_A   (1<<6)
368 #define WPI_ANTENNA_B   (1<<7)
369 #define WPI_ANTENNA_BOTH        (WPI_ANTENNA_A|WPI_ANTENNA_B)
370         uint8_t         add_imm;
371         uint8_t         del_imm;
372         uint16_t        add_imm_start;
373 } __packed;
374
375 /* structure for command WPI_CMD_TX_DATA */
376 struct wpi_cmd_data {
377         uint16_t        len;
378         uint16_t        lnext;
379         uint32_t        flags;
380 #define WPI_TX_NEED_RTS         (1 <<  1)
381 #define WPI_TX_NEED_CTS         (1 <<  2)
382 #define WPI_TX_NEED_ACK         (1 <<  3)
383 #define WPI_TX_FULL_TXOP        (1 <<  7)
384 #define WPI_TX_BT_DISABLE       (1 << 12) /* bluetooth coexistence */
385 #define WPI_TX_AUTO_SEQ         (1 << 13)
386 #define WPI_TX_INSERT_TSTAMP    (1 << 16)
387
388         uint8_t         rate;
389         uint8_t         id;
390         uint8_t         tid;
391         uint8_t         security;
392         uint8_t         key[IEEE80211_KEYBUF_SIZE];
393         uint8_t         tkip[IEEE80211_WEP_MICLEN];
394         uint32_t        fnext;
395         uint32_t        lifetime;
396 #define WPI_LIFETIME_INFINITE   0xffffffff
397         uint8_t         ofdm_mask;
398         uint8_t         cck_mask;
399         uint8_t         rts_ntries;
400         uint8_t         data_ntries;
401         uint16_t        timeout;
402         uint16_t        txop;
403         struct          ieee80211_frame wh;
404 } __packed;
405
406 /* structure for command WPI_CMD_SET_BEACON */
407 struct wpi_cmd_beacon {
408         uint16_t        len;
409         uint16_t        reserved1;
410         uint32_t        flags;  /* same as wpi_cmd_data */
411         uint8_t         rate;
412         uint8_t         id;
413         uint8_t         reserved2[30];
414         uint32_t        lifetime;
415         uint8_t         ofdm_mask;
416         uint8_t         cck_mask;
417         uint16_t        reserved3[3];
418         uint16_t        tim;
419         uint8_t         timsz;
420         uint8_t         reserved4;
421         struct          ieee80211_frame wh;
422 } __packed;
423
424 /* structure for notification WPI_MISSED_BEACON */
425 struct wpi_missed_beacon {
426     uint32_t consecutive;
427     uint32_t total;
428     uint32_t expected;
429     uint32_t received;
430 } __packed;
431
432
433 /* structure for WPI_CMD_MRR_SETUP */
434 struct wpi_mrr_setup {
435         uint8_t which;
436 #define WPI_MRR_CTL     0
437 #define WPI_MRR_DATA    1
438
439         uint8_t         reserved[3];
440
441         struct {
442                 uint8_t signal;
443                 uint8_t flags;
444                 uint8_t ntries;
445                 uint8_t next;
446 #define WPI_OFDM6       0
447 #define WPI_OFDM54      7
448 #define WPI_CCK1        8
449 #define WPI_CCK2        9
450 #define WPI_CCK11       11
451
452         } __attribute__((__packed__))   rates[WPI_CCK11 + 1];
453 } __packed;
454
455 /* structure for WPI_CMD_SET_LED */
456 struct wpi_cmd_led {
457         uint32_t        unit;   /* multiplier (in usecs) */
458         uint8_t         which;
459 #define WPI_LED_ACTIVITY        1
460 #define WPI_LED_LINK            2
461
462         uint8_t         off;
463         uint8_t         on;
464         uint8_t         reserved;
465 } __packed;
466
467 /* structure for WPI_CMD_SET_POWER_MODE */
468 struct wpi_power {
469         uint32_t        flags;
470 #define WPI_POWER_CAM   0       /* constantly awake mode */
471         uint32_t        rx_timeout;
472         uint32_t        tx_timeout;
473         uint32_t        sleep[5];
474 } __packed;
475
476 /* structure for command WPI_CMD_SCAN */
477 struct wpi_scan_hdr {
478         uint16_t        len;
479         uint8_t         reserved1;
480         uint8_t         nchan;
481         uint16_t        quiet;
482         uint16_t        threshold;
483         uint16_t        promotion;
484         uint16_t        reserved2;
485         uint32_t        maxtimeout;
486         uint32_t        suspend;
487         uint32_t        flags;
488         uint32_t        filter;
489
490 struct {
491         uint16_t        len;
492         uint16_t        lnext;
493         uint32_t        flags;
494         uint8_t         rate;
495         uint8_t         id;
496         uint8_t         tid;
497         uint8_t         security;
498         uint8_t         key[IEEE80211_KEYBUF_SIZE];
499         uint8_t         tkip[IEEE80211_WEP_MICLEN];
500         uint32_t        fnext;
501         uint32_t        lifetime;
502         uint8_t         ofdm_mask;
503         uint8_t         cck_mask;
504         uint8_t         rts_ntries;
505         uint8_t         data_ntries;
506         uint16_t        timeout;
507         uint16_t        txop;
508 }       tx __attribute__((__packed__));
509
510 #define WPI_SCAN_MAX_ESSIDS     4
511         struct {
512             uint8_t             id;
513             uint8_t             esslen;
514             uint8_t             essid[32];
515         }scan_essids[WPI_SCAN_MAX_ESSIDS];
516         /* followed by probe request body */
517         /* followed by nchan x wpi_scan_chan */
518 } __packed;
519
520 struct wpi_scan_chan {
521         uint8_t         flags;
522         uint8_t         chan;
523 #define WPI_CHAN_ACTIVE (1 << 0)
524 #define WPI_CHAN_DIRECT (1 << 1)
525         uint8_t         gain_radio;
526         uint8_t         gain_dsp;
527         uint16_t        active;         /* msecs */
528         uint16_t        passive;        /* msecs */
529 } __packed;
530
531 /* structure for WPI_CMD_BLUETOOTH */
532 struct wpi_bluetooth {
533         uint8_t         flags;
534         uint8_t         lead;
535         uint8_t         kill;
536         uint8_t         reserved;
537         uint32_t        ack;
538         uint32_t        cts;
539 } __packed;
540
541 /* structure for command WPI_CMD_TXPOWER */
542 struct wpi_cmd_txpower {
543
544         uint8_t         band;
545 #define WPI_RATE_5GHZ   0
546 #define WPI_RATE_2GHZ   1
547         uint8_t         reserved;
548         uint16_t        channel;
549
550 #define WPI_RATE_MAPPING_COUNT 12
551         struct {
552             uint8_t     rate;
553             uint8_t     gain_radio;
554             uint8_t     gain_dsp;
555             uint8_t     reserved;
556         } __packed rates [WPI_RATE_MAPPING_COUNT];
557
558 } __packed;
559
560
561
562 #define WPI_FW_MAIN_TEXT_MAXSZ (80 * 1024 )
563 #define WPI_FW_MAIN_DATA_MAXSZ (32 * 1024 )
564 #define WPI_FW_INIT_TEXT_MAXSZ (80 * 1024 )
565 #define WPI_FW_INIT_DATA_MAXSZ (32 * 1024 )
566 #define WPI_FW_BOOT_TEXT_MAXSZ 1024
567
568 #define WPI_FW_UPDATED  (1 << 31 )
569
570 /* firmware image header */
571 struct wpi_firmware_hdr {
572
573 #define WPI_FW_MINVERSION 2144
574
575         uint32_t        version;
576         uint32_t        rtextsz;
577         uint32_t        rdatasz;
578         uint32_t        itextsz;
579         uint32_t        idatasz;
580         uint32_t        btextsz;
581 } __packed;
582
583 /* structure for WPI_UC_READY notification */
584 struct wpi_ucode_info {
585         uint32_t        version;
586         uint8_t         revision[8];
587         uint8_t         type;
588         uint8_t         subtype;
589         uint16_t        reserved;
590         uint32_t        logptr;
591         uint32_t        errorptr;
592         uint32_t        timestamp;
593         uint32_t        valid;
594 } __packed;
595
596 /* structure for WPI_START_SCAN notification */
597 struct wpi_start_scan {
598         uint64_t        tstamp;
599         uint32_t        tbeacon;
600         uint8_t         chan;
601         uint8_t         band;
602         uint16_t        reserved;
603         uint32_t        status;
604 } __packed;
605
606 /* structure for WPI_STOP_SCAN notification */
607 struct wpi_stop_scan {
608         uint8_t         nchan;
609         uint8_t         status;
610         uint8_t         reserved;
611         uint8_t         chan;
612         uint64_t        tsf;
613 } __packed;
614
615 #define WPI_EEPROM_MAC          0x015
616 #define WPI_EEPROM_REVISION     0x035
617 #define WPI_EEPROM_CAPABILITIES 0x045
618 #define WPI_EEPROM_TYPE         0x04a
619 #define WPI_EEPROM_DOMAIN       0x060
620 #define WPI_EEPROM_BAND1        0x063
621 #define WPI_EEPROM_BAND2        0x072
622 #define WPI_EEPROM_BAND3        0x080
623 #define WPI_EEPROM_BAND4        0x08d
624 #define WPI_EEPROM_BAND5        0x099
625 #define WPI_EEPROM_POWER_GRP    0x100
626
627 struct wpi_eeprom_chan {
628         uint8_t flags;
629 #define WPI_EEPROM_CHAN_VALID   (1<<0)
630 #define WPI_EEPROM_CHAN_IBSS    (1<<1)
631 #define WPI_EEPROM_CHAN_ACTIVE  (1<<3)
632 #define WPI_EEPROM_CHAN_RADAR   (1<<4)
633
634         int8_t  maxpwr;
635 } __packed;
636
637 struct wpi_eeprom_sample {
638     uint8_t     index;
639     int8_t      power;
640     uint16_t    volt;
641 };
642
643 #define WPI_POWER_GROUPS_COUNT  5
644
645 struct wpi_eeprom_group {
646     struct      wpi_eeprom_sample samples[5];
647     int32_t     coef[5];
648     int32_t     corr[5];
649     int8_t      maxpwr;
650     uint8_t     chan;
651     int16_t     temp;
652 } __packed;
653
654 #define WPI_CHAN_BANDS_COUNT    5
655 #define WPI_MAX_CHAN_PER_BAND   14
656
657 static const struct wpi_chan_band {
658     uint32_t    addr;   /* offset in EEPROM */
659     uint8_t     nchan;
660     uint8_t     chan[WPI_MAX_CHAN_PER_BAND];
661 } wpi_bands[5] = {
662     { WPI_EEPROM_BAND1, 14,
663         { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }},
664     { WPI_EEPROM_BAND2, 13,
665         { 183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16 }},
666     { WPI_EEPROM_BAND3, 12,
667         { 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64 }},
668     { WPI_EEPROM_BAND4, 11,
669         { 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140 }},
670     { WPI_EEPROM_BAND5, 6,
671         { 145, 149, 153, 157, 161, 165 }}
672 };
673
674 #define WPI_MAX_PWR_INDEX       77
675
676 /*
677  * RF Tx gain values from highest to lowest power (values obtained from
678  * the reference driver.)
679  */
680 static const uint8_t wpi_rf_gain_2ghz[WPI_MAX_PWR_INDEX + 1] = {
681     0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xbb, 0xbb, 0xbb,
682     0xbb, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xd3, 0xd3, 0xb3, 0xb3, 0xb3,
683     0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x73, 0xeb, 0xeb, 0xeb,
684     0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xab, 0xab, 0xab, 0x8b,
685     0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xc3, 0xc3, 0xc3, 0xc3, 0xa3,
686     0xa3, 0xa3, 0xa3, 0x83, 0x83, 0x83, 0x83, 0x63, 0x63, 0x63, 0x63,
687     0x43, 0x43, 0x43, 0x43, 0x23, 0x23, 0x23, 0x23, 0x03, 0x03, 0x03,
688     0x03
689 };
690
691 static const uint8_t wpi_rf_gain_5ghz[WPI_MAX_PWR_INDEX + 1] = {
692     0xfb, 0xfb, 0xfb, 0xdb, 0xdb, 0xbb, 0xbb, 0x9b, 0x9b, 0x7b, 0x7b,
693     0x7b, 0x7b, 0x5b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x1b, 0x1b,
694     0x1b, 0x73, 0x73, 0x73, 0x53, 0x53, 0x53, 0x53, 0x53, 0x33, 0x33,
695     0x33, 0x33, 0x13, 0x13, 0x13, 0x13, 0x13, 0xab, 0xab, 0xab, 0x8b,
696     0x8b, 0x8b, 0x8b, 0x6b, 0x6b, 0x6b, 0x6b, 0x4b, 0x4b, 0x4b, 0x4b,
697     0x2b, 0x2b, 0x2b, 0x2b, 0x0b, 0x0b, 0x0b, 0x0b, 0x83, 0x83, 0x63,
698     0x63, 0x63, 0x63, 0x43, 0x43, 0x43, 0x43, 0x23, 0x23, 0x23, 0x23,
699     0x03
700 };
701
702 /*
703  * DSP pre-DAC gain values from highest to lowest power (values obtained
704  * from the reference driver.)
705  */
706 static const uint8_t wpi_dsp_gain_2ghz[WPI_MAX_PWR_INDEX + 1] = {
707     0x7f, 0x7f, 0x7f, 0x7f, 0x7d, 0x6e, 0x69, 0x62, 0x7d, 0x73, 0x6c,
708     0x63, 0x77, 0x6f, 0x69, 0x61, 0x5c, 0x6a, 0x64, 0x78, 0x71, 0x6b,
709     0x7d, 0x77, 0x70, 0x6a, 0x65, 0x61, 0x5b, 0x6b, 0x79, 0x73, 0x6d,
710     0x7f, 0x79, 0x73, 0x6c, 0x66, 0x60, 0x5c, 0x6e, 0x68, 0x62, 0x74,
711     0x7d, 0x77, 0x71, 0x6b, 0x65, 0x60, 0x71, 0x6a, 0x66, 0x5f, 0x71,
712     0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f,
713     0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66, 0x5f, 0x71, 0x6a, 0x66,
714     0x5f
715 };
716
717 static const uint8_t wpi_dsp_gain_5ghz[WPI_MAX_PWR_INDEX + 1] = {
718     0x7f, 0x78, 0x72, 0x77, 0x65, 0x71, 0x66, 0x72, 0x67, 0x75, 0x6b,
719     0x63, 0x5c, 0x6c, 0x7d, 0x76, 0x6d, 0x66, 0x60, 0x5a, 0x68, 0x62,
720     0x5c, 0x76, 0x6f, 0x68, 0x7e, 0x79, 0x71, 0x69, 0x63, 0x76, 0x6f,
721     0x68, 0x62, 0x74, 0x6d, 0x66, 0x62, 0x5d, 0x71, 0x6b, 0x63, 0x78,
722     0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63,
723     0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x6b, 0x63, 0x78,
724     0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63, 0x78, 0x71, 0x6b, 0x63,
725     0x78
726 };
727
728
729 #define WPI_READ(sc, reg)                                               \
730     bus_space_read_4((sc)->sc_st, (sc)->sc_sh, (reg))
731
732 #define WPI_WRITE(sc, reg, val)                                         \
733     bus_space_write_4((sc)->sc_st, (sc)->sc_sh, (reg), (val))
734
735 #define WPI_WRITE_REGION_4(sc, offset, datap, count)                    \
736     bus_space_write_region_4((sc)->sc_st, (sc)->sc_sh, (offset),        \
737                              (datap), (count))