1 /**** (legal) claimer in README
2 ** Copyright (C) 2003 ACX100 Open Source Project
5 #include <linux/version.h>
6 #include <linux/module.h>
7 #include <linux/kernel.h>
8 #include <linux/sched.h>
9 #include <linux/types.h>
10 #include <linux/slab.h>
11 #include <linux/delay.h>
12 #include <linux/proc_fs.h>
13 #include <linux/if_arp.h>
14 #include <linux/rtnetlink.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/wireless.h>
19 #include <linux/vmalloc.h>
20 #include <linux/firmware.h>
21 //#include <net/iw_handler.h>
22 #include <linux/ethtool.h>
23 //#include <linux/utsrelease.h>
28 /***********************************************************************
31 static void acx_l_rx(acx_device_t
* adev
, rxbuffer_t
* rxbuf
);
35 /***********************************************************************
38 unsigned int acx_debug
/* will add __read_mostly later */ = ACX_DEFAULT_MSG
;
39 /* parameter is 'debug', corresponding var is acx_debug */
40 module_param_named(debug
, acx_debug
, uint
, 0);
41 MODULE_PARM_DESC(debug
, "Debug level mask (see L_xxx constants)");
45 MODULE_LICENSE("Dual MPL/GPL");
47 /* USB had this: MODULE_AUTHOR("Martin Wawro <martin.wawro AT uni-dortmund.de>"); */
48 MODULE_AUTHOR("ACX100 Open Source Driver development team");
50 ("Driver for TI ACX1xx based wireless cards (CardBus/PCI/USB)");
53 MODULE_VERSION(ACX_RELEASE
);
56 /***********************************************************************
58 /* Probably a number of acx's intermediate buffers for USB transfers,
59 ** not to be confused with number of descriptors in tx/rx rings
60 ** (which are not directly accessible to host in USB devices) */
65 /***********************************************************************
68 /* minutes to wait until next radio recalibration: */
69 #define RECALIB_PAUSE 5
71 /* Please keep acx_reg_domain_ids_len in sync... */
72 const u8 acx_reg_domain_ids
[acx_reg_domain_ids_len
] =
73 { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40, 0x41, 0x51 };
74 static const u16 reg_domain_channel_masks
[acx_reg_domain_ids_len
] =
75 { 0x07ff, 0x07ff, 0x1fff, 0x0600, 0x1e00, 0x2000, 0x3fff, 0x01fc };
77 acx_reg_domain_strings
[] = {
78 /* 0 */ " 1-11 FCC (USA)",
79 /* 1 */ " 1-11 DOC/IC (Canada)",
80 /* BTW: WLAN use in ETSI is regulated by ETSI standard EN 300 328-2 V1.1.2 */
81 /* 2 */ " 1-13 ETSI (Europe)",
82 /* 3 */ "10-11 Spain",
83 /* 4 */ "10-13 France",
84 /* 5 */ " 14 MKK (Japan)",
86 /* 7 */ " 3-9 Israel (not all firmware versions)",
87 NULL
/* needs to remain as last entry */
92 /***********************************************************************
95 #ifdef PARANOID_LOCKING
96 static unsigned max_lock_time
;
97 static unsigned max_sem_time
;
99 /* Obvious or linux kernel specific derived code follows: */
101 void acx_lock_unhold()
106 void acx_sem_unhold()
111 static inline const char *sanitize_str(const char *s
)
113 const char *t
= strrchr(s
, '/');
119 void acx_lock_debug(acx_device_t
* adev
, const char *where
)
121 unsigned int count
= 100 * 1000 * 1000;
122 where
= sanitize_str(where
);
124 if (!spin_is_locked(&adev
->spinlock
))
129 printk(KERN_EMERG
"LOCKUP: already taken at %s!\n",
133 adev
->last_lock
= where
;
134 rdtscl(adev
->lock_time
);
137 void acx_unlock_debug(acx_device_t
* adev
, const char *where
)
140 if (!spin_is_locked(&adev
->spinlock
)) {
141 where
= sanitize_str(where
);
142 printk(KERN_EMERG
"STRAY UNLOCK at %s!\n", where
);
146 if (acx_debug
& L_LOCK
) {
149 diff
-= adev
->lock_time
;
150 if (diff
> max_lock_time
) {
151 where
= sanitize_str(where
);
152 printk("max lock hold time %ld CPU ticks from %s "
153 "to %s\n", diff
, adev
->last_lock
, where
);
154 max_lock_time
= diff
;
158 #endif /* PARANOID_LOCKING */
161 /***********************************************************************
165 static int acx_debug_func_indent
;
167 #define FUNC_INDENT_INCREMENT 2
170 #define TIMESTAMP(d) unsigned long d; rdtscl(d)
172 #define TIMESTAMP(d) unsigned long d = jiffies
175 static const char spaces
[] = " " " "; /* Nx10 spaces */
177 void log_fn_enter(const char *funcname
)
182 indent
= acx_debug_func_indent
;
183 if (indent
>= sizeof(spaces
))
184 indent
= sizeof(spaces
) - 1;
186 printk("%08ld %s==> %s\n",
187 d
% 100000000, spaces
+ (sizeof(spaces
) - 1) - indent
, funcname
);
189 acx_debug_func_indent
+= FUNC_INDENT_INCREMENT
;
191 void log_fn_exit(const char *funcname
)
196 acx_debug_func_indent
-= FUNC_INDENT_INCREMENT
;
198 indent
= acx_debug_func_indent
;
199 if (indent
>= sizeof(spaces
))
200 indent
= sizeof(spaces
) - 1;
202 printk("%08ld %s<== %s\n",
203 d
% 100000000, spaces
+ (sizeof(spaces
) - 1) - indent
, funcname
);
205 void log_fn_exit_v(const char *funcname
, int v
)
210 acx_debug_func_indent
-= FUNC_INDENT_INCREMENT
;
212 indent
= acx_debug_func_indent
;
213 if (indent
>= sizeof(spaces
))
214 indent
= sizeof(spaces
) - 1;
216 printk("%08ld %s<== %s: %08X\n",
218 spaces
+ (sizeof(spaces
) - 1) - indent
, funcname
, v
);
220 #endif /* ACX_DEBUG > 1 */
223 /***********************************************************************
224 ** Basically a mdelay/msleep with logging
226 void acx_s_mwait(int ms
)
238 /***********************************************************************
239 ** Not inlined: it's larger than it seems
241 void acx_print_mac(const char *head
, const u8
* mac
, const char *tail
)
243 printk("%s" MACSTR
"%s", head
, MAC(mac
), tail
);
249 /***********************************************************************
250 ** acx_cmd_status_str
252 const char *acx_cmd_status_str(unsigned int state
)
254 static const char *const cmd_error_strings
[] = {
258 "Invalid Information Element",
260 "Channel invalid in current regulatory domain",
262 "Command rejected (read-only information element)",
273 return state
< ARRAY_SIZE(cmd_error_strings
) ?
274 cmd_error_strings
[state
] : "?";
277 /***********************************************************************
280 void acx_dump_bytes(const void *data
, int num
)
282 const u8
*ptr
= (const u8
*)data
;
292 printk("%02X %02X %02X %02X %02X %02X %02X %02X "
293 "%02X %02X %02X %02X %02X %02X %02X %02X\n",
294 ptr
[0], ptr
[1], ptr
[2], ptr
[3],
295 ptr
[4], ptr
[5], ptr
[6], ptr
[7],
296 ptr
[8], ptr
[9], ptr
[10], ptr
[11],
297 ptr
[12], ptr
[13], ptr
[14], ptr
[15]);
303 printk("%02X \n", *ptr
++);
304 printk("%02X\n", *ptr
);
313 /***********************************************************************
314 ** acx_s_get_firmware_version
318 void acx_s_get_firmware_version(acx_device_t
* adev
)
321 u8 hexarr
[4] = { 0, 0, 0, 0 };
322 int hexidx
= 0, val
= 0;
328 memset(fw
.fw_id
, 'E', FW_ID_SIZE
);
329 acx_s_interrogate(adev
, &fw
, ACX1xx_IE_FWREV
);
330 memcpy(adev
->firmware_version
, fw
.fw_id
, FW_ID_SIZE
);
331 adev
->firmware_version
[FW_ID_SIZE
] = '\0';
333 log(L_DEBUG
, "fw_ver: fw_id='%s' hw_id=%08X\n",
334 adev
->firmware_version
, fw
.hw_id
);
336 if (strncmp(fw
.fw_id
, "Rev ", 4) != 0) {
337 printk("acx: strange firmware version string "
338 "'%s', please report\n", adev
->firmware_version
);
339 adev
->firmware_numver
= 0x01090407; /* assume 1.9.4.7 */
344 if ((c
== '.') || (c
== '\0')) {
345 hexarr
[hexidx
++] = val
;
346 if ((hexidx
> 3) || (c
== '\0')) /* end? */
351 if ((c
>= '0') && (c
<= '9'))
354 c
= c
- 'a' + (char)10;
358 adev
->firmware_numver
= (u32
) ((hexarr
[0] << 24) |
360 | (hexarr
[2] << 8) | hexarr
[3]);
361 log(L_DEBUG
, "firmware_numver 0x%08X\n", adev
->firmware_numver
);
363 if (IS_ACX111(adev
)) {
364 if (adev
->firmware_numver
== 0x00010011) {
365 /* This one does not survive floodpinging */
366 printk("acx: firmware '%s' is known to be buggy, "
367 "please upgrade\n", adev
->firmware_version
);
371 adev
->firmware_id
= le32_to_cpu(fw
.hw_id
);
373 /* we're able to find out more detailed chip names now */
374 switch (adev
->firmware_id
& 0xffff0000) {
377 adev
->chip_name
= "TNETW1100A";
380 adev
->chip_name
= "TNETW1100B";
384 adev
->chip_name
= "TNETW1130";
386 case 0x04030000: /* 0x04030101 is TNETW1450 */
387 adev
->chip_name
= "TNETW1450";
390 printk("acx: unknown chip ID 0x%08X, "
391 "please report\n", adev
->firmware_id
);
399 /***********************************************************************
400 ** acx_display_hardware_details
402 ** Displays hw/fw version, radio type etc...
406 void acx_display_hardware_details(acx_device_t
* adev
)
408 const char *radio_str
, *form_str
;
412 switch (adev
->radio_type
) {
419 case RADIO_RALINK_15
:
420 radio_str
= "Ralink";
425 case RADIO_UNKNOWN_17
:
426 /* TI seems to have a radio which is
427 * additionally 802.11a capable, too */
428 radio_str
= "802.11a/b/g radio?! Please report";
430 case RADIO_UNKNOWN_19
:
431 radio_str
= "A radio used by Safecom cards?! Please report";
433 case RADIO_UNKNOWN_1B
:
434 radio_str
= "An unknown radio used by TNETW1450 USB adapters";
437 radio_str
= "UNKNOWN, please report radio type name!";
441 switch (adev
->form_factor
) {
443 form_str
= "unspecified";
446 form_str
= "(mini-)PCI / CardBus";
452 form_str
= "Compact Flash";
455 form_str
= "UNKNOWN, please report";
459 printk("acx: chipset %s, radio type 0x%02X (%s), "
460 "form factor 0x%02X (%s), EEPROM version 0x%02X, "
461 "uploaded firmware '%s'\n",
462 adev
->chip_name
, adev
->radio_type
, radio_str
,
463 adev
->form_factor
, form_str
, adev
->eeprom_version
,
464 adev
->firmware_version
);
470 /***********************************************************************
471 ** acx_e_get_stats, acx_e_get_wireless_stats
474 acx_e_get_stats(struct ieee80211_hw
*hw
,
475 struct ieee80211_low_level_stats
*stats
)
477 acx_device_t
*adev
= ieee2adev(hw
);
479 acx_lock(adev
, flags
);
480 memcpy(stats
, &adev
->ieee_stats
, sizeof(*stats
));
481 acx_unlock(adev
, flags
);
486 /***********************************************************************
487 ** maps acx111 tx descr rate field to acx100 one
489 const u8 acx_bitpos2rate100
[] = {
493 RATE100_2
, /* 3, should not happen */
494 RATE100_2
, /* 4, should not happen */
496 RATE100_2
, /* 6, should not happen */
497 RATE100_2
, /* 7, should not happen */
499 RATE100_2
, /* 9, should not happen */
500 RATE100_2
, /* 10, should not happen */
501 RATE100_2
, /* 11, should not happen */
502 RATE100_2
, /* 12, should not happen */
503 RATE100_2
, /* 13, should not happen */
504 RATE100_2
, /* 14, should not happen */
505 RATE100_2
, /* 15, should not happen */
508 u8
acx_rate111to100(u16 r
)
510 return acx_bitpos2rate100
[highest_bit(r
)];
514 /***********************************************************************
515 ** Calculate level like the feb 2003 windows driver seems to do
517 static u8
acx_signal_to_winlevel(u8 rawlevel
)
519 /* u8 winlevel = (u8) (0.5 + 0.625 * rawlevel); */
520 u8 winlevel
= ((4 + (rawlevel
* 5)) / 8);
527 u8
acx_signal_determine_quality(u8 signal
, u8 noise
)
531 qual
= (((signal
- 30) * 100 / 70) + (100 - noise
* 4)) / 2;
541 /***********************************************************************
542 ** Interrogate/configure commands
545 /* FIXME: the lengths given here probably aren't always correct.
546 * They should be gradually replaced by proper "sizeof(acx1XX_ie_XXXX)-4",
547 * unless the firmware actually expects a different length than the struct length */
548 static const u16 acx100_ie_len
[] = {
550 ACX100_IE_ACX_TIMER_LEN
,
551 sizeof(acx100_ie_powersave_t
) - 4, /* is that 6 or 8??? */
552 ACX1xx_IE_QUEUE_CONFIG_LEN
,
553 ACX100_IE_BLOCK_SIZE_LEN
,
554 ACX1xx_IE_MEMORY_CONFIG_OPTIONS_LEN
,
555 ACX1xx_IE_RATE_FALLBACK_LEN
,
556 ACX100_IE_WEP_OPTIONS_LEN
,
557 ACX1xx_IE_MEMORY_MAP_LEN
, /* ACX1xx_IE_SSID_LEN, */
559 ACX1xx_IE_ASSOC_ID_LEN
,
561 ACX111_IE_CONFIG_OPTIONS_LEN
,
563 ACX1xx_IE_FCS_ERROR_COUNT_LEN
,
564 ACX1xx_IE_MEDIUM_USAGE_LEN
,
565 ACX1xx_IE_RXCONFIG_LEN
,
568 sizeof(fw_stats_t
) - 4,
570 ACX1xx_IE_FEATURE_CONFIG_LEN
,
571 ACX111_IE_KEY_CHOOSE_LEN
,
572 ACX1FF_IE_MISC_CONFIG_TABLE_LEN
,
573 ACX1FF_IE_WONE_CONFIG_LEN
,
575 ACX1FF_IE_TID_CONFIG_LEN
,
579 ACX1FF_IE_CALIB_ASSESSMENT_LEN
,
580 ACX1FF_IE_BEACON_FILTER_OPTIONS_LEN
,
581 ACX1FF_IE_LOW_RSSI_THRESH_OPT_LEN
,
582 ACX1FF_IE_NOISE_HISTOGRAM_RESULTS_LEN
,
584 ACX1FF_IE_PACKET_DETECT_THRESH_LEN
,
585 ACX1FF_IE_TX_CONFIG_OPTIONS_LEN
,
586 ACX1FF_IE_CCA_THRESHOLD_LEN
,
587 ACX1FF_IE_EVENT_MASK_LEN
,
588 ACX1FF_IE_DTIM_PERIOD_LEN
,
590 ACX1FF_IE_ACI_CONFIG_SET_LEN
,
597 ACX1FF_IE_EEPROM_VER_LEN
,
600 static const u16 acx100_ie_len_dot11
[] = {
602 ACX1xx_IE_DOT11_STATION_ID_LEN
,
604 ACX100_IE_DOT11_BEACON_PERIOD_LEN
,
605 ACX1xx_IE_DOT11_DTIM_PERIOD_LEN
,
606 ACX1xx_IE_DOT11_SHORT_RETRY_LIMIT_LEN
,
607 ACX1xx_IE_DOT11_LONG_RETRY_LIMIT_LEN
,
608 ACX100_IE_DOT11_WEP_DEFAULT_KEY_WRITE_LEN
,
609 ACX1xx_IE_DOT11_MAX_XMIT_MSDU_LIFETIME_LEN
,
611 ACX1xx_IE_DOT11_CURRENT_REG_DOMAIN_LEN
,
612 ACX1xx_IE_DOT11_CURRENT_ANTENNA_LEN
,
614 ACX1xx_IE_DOT11_TX_POWER_LEVEL_LEN
,
615 ACX1xx_IE_DOT11_CURRENT_CCA_MODE_LEN
,
616 ACX100_IE_DOT11_ED_THRESHOLD_LEN
,
617 ACX1xx_IE_DOT11_WEP_DEFAULT_KEY_SET_LEN
,
623 static const u16 acx111_ie_len
[] = {
625 ACX100_IE_ACX_TIMER_LEN
,
626 sizeof(acx111_ie_powersave_t
) - 4,
627 ACX1xx_IE_QUEUE_CONFIG_LEN
,
628 ACX100_IE_BLOCK_SIZE_LEN
,
629 ACX1xx_IE_MEMORY_CONFIG_OPTIONS_LEN
,
630 ACX1xx_IE_RATE_FALLBACK_LEN
,
631 ACX100_IE_WEP_OPTIONS_LEN
,
632 ACX1xx_IE_MEMORY_MAP_LEN
, /* ACX1xx_IE_SSID_LEN, */
634 ACX1xx_IE_ASSOC_ID_LEN
,
636 ACX111_IE_CONFIG_OPTIONS_LEN
,
638 ACX1xx_IE_FCS_ERROR_COUNT_LEN
,
639 ACX1xx_IE_MEDIUM_USAGE_LEN
,
640 ACX1xx_IE_RXCONFIG_LEN
,
643 sizeof(fw_stats_t
) - 4,
645 ACX1xx_IE_FEATURE_CONFIG_LEN
,
646 ACX111_IE_KEY_CHOOSE_LEN
,
647 ACX1FF_IE_MISC_CONFIG_TABLE_LEN
,
648 ACX1FF_IE_WONE_CONFIG_LEN
,
650 ACX1FF_IE_TID_CONFIG_LEN
,
654 ACX1FF_IE_CALIB_ASSESSMENT_LEN
,
655 ACX1FF_IE_BEACON_FILTER_OPTIONS_LEN
,
656 ACX1FF_IE_LOW_RSSI_THRESH_OPT_LEN
,
657 ACX1FF_IE_NOISE_HISTOGRAM_RESULTS_LEN
,
659 ACX1FF_IE_PACKET_DETECT_THRESH_LEN
,
660 ACX1FF_IE_TX_CONFIG_OPTIONS_LEN
,
661 ACX1FF_IE_CCA_THRESHOLD_LEN
,
662 ACX1FF_IE_EVENT_MASK_LEN
,
663 ACX1FF_IE_DTIM_PERIOD_LEN
,
665 ACX1FF_IE_ACI_CONFIG_SET_LEN
,
672 ACX1FF_IE_EEPROM_VER_LEN
,
675 static const u16 acx111_ie_len_dot11
[] = {
677 ACX1xx_IE_DOT11_STATION_ID_LEN
,
679 ACX100_IE_DOT11_BEACON_PERIOD_LEN
,
680 ACX1xx_IE_DOT11_DTIM_PERIOD_LEN
,
681 ACX1xx_IE_DOT11_SHORT_RETRY_LIMIT_LEN
,
682 ACX1xx_IE_DOT11_LONG_RETRY_LIMIT_LEN
,
683 ACX100_IE_DOT11_WEP_DEFAULT_KEY_WRITE_LEN
,
684 ACX1xx_IE_DOT11_MAX_XMIT_MSDU_LIFETIME_LEN
,
686 ACX1xx_IE_DOT11_CURRENT_REG_DOMAIN_LEN
,
687 ACX1xx_IE_DOT11_CURRENT_ANTENNA_LEN
,
689 ACX1xx_IE_DOT11_TX_POWER_LEVEL_LEN
,
690 ACX1xx_IE_DOT11_CURRENT_CCA_MODE_LEN
,
691 ACX100_IE_DOT11_ED_THRESHOLD_LEN
,
692 ACX1xx_IE_DOT11_WEP_DEFAULT_KEY_SET_LEN
,
700 #define FUNC "configure"
702 int acx_s_configure(acx_device_t
* adev
, void *pdr
, int type
)
706 acx_s_configure_debug(acx_device_t
* adev
, void *pdr
, int type
,
714 len
= adev
->ie_len
[type
];
716 len
= adev
->ie_len_dot11
[type
- 0x1000];
718 log(L_CTL
, FUNC
"(type:%s,len:%u)\n", typestr
, len
);
719 if (unlikely(!len
)) {
720 log(L_DEBUG
, "zero-length type %s?!\n", typestr
);
723 ((acx_ie_generic_t
*) pdr
)->type
= cpu_to_le16(type
);
724 ((acx_ie_generic_t
*) pdr
)->len
= cpu_to_le16(len
);
725 res
= acx_s_issue_cmd(adev
, ACX1xx_CMD_CONFIGURE
, pdr
, len
+ 4);
726 if (unlikely(OK
!= res
)) {
728 printk("%s: " FUNC
"(type:%s) FAILED\n", wiphy_name(adev
->ieee
->wiphy
),
731 printk("%s: " FUNC
"(type:0x%X) FAILED\n", wiphy_name(adev
->ieee
->wiphy
),
734 /* dump_stack() is already done in issue_cmd() */
740 #define FUNC "interrogate"
742 int acx_s_interrogate(acx_device_t
* adev
, void *pdr
, int type
)
746 acx_s_interrogate_debug(acx_device_t
* adev
, void *pdr
, int type
,
755 /* FIXME: no check whether this exceeds the array yet.
756 * We should probably remember the number of entries... */
758 len
= adev
->ie_len
[type
];
760 len
= adev
->ie_len_dot11
[type
- 0x1000];
762 log(L_CTL
, FUNC
"(type:%s,len:%u)\n", typestr
, len
);
764 ((acx_ie_generic_t
*) pdr
)->type
= cpu_to_le16(type
);
765 ((acx_ie_generic_t
*) pdr
)->len
= cpu_to_le16(len
);
766 res
= acx_s_issue_cmd(adev
, ACX1xx_CMD_INTERROGATE
, pdr
, len
+ 4);
767 if (unlikely(OK
!= res
)) {
769 printk("%s: " FUNC
"(type:%s) FAILED\n", wiphy_name(adev
->ieee
->wiphy
),
772 printk("%s: " FUNC
"(type:0x%X) FAILED\n", wiphy_name(adev
->ieee
->wiphy
),
775 /* dump_stack() is already done in issue_cmd() */
783 void great_inquisitor(acx_device_t
* adev
)
788 /* 0x200 was too large here: */
795 /* 0..0x20, 0x1000..0x1020 */
796 for (type
= 0; type
<= 0x1020; type
++) {
799 ie
.type
= cpu_to_le16(type
);
800 ie
.len
= cpu_to_le16(sizeof(ie
) - 4);
801 acx_s_issue_cmd(adev
, ACX1xx_CMD_INTERROGATE
, &ie
, sizeof(ie
));
808 #ifdef CONFIG_PROC_FS
809 /***********************************************************************
812 /***********************************************************************
814 ** Generate content for our /proc entry
817 ** buf is a pointer to write output to
818 ** adev is the usual pointer to our private struct acx_device
820 ** number of bytes actually written to buf
824 static int acx_l_proc_output(char *buf
, acx_device_t
* adev
)
831 "acx driver version:\t\t" ACX_RELEASE
"\n"
832 "Wireless extension version:\t" STRING(WIRELESS_EXT
) "\n"
833 "chip name:\t\t\t%s (0x%08X)\n"
834 "radio type:\t\t\t0x%02X\n"
835 "form factor:\t\t\t0x%02X\n"
836 "EEPROM version:\t\t\t0x%02X\n"
837 "firmware version:\t\t%s (0x%08X)\n",
838 adev
->chip_name
, adev
->firmware_id
,
841 adev
->eeprom_version
,
842 adev
->firmware_version
, adev
->firmware_numver
);
849 /***********************************************************************
851 static int acx_s_proc_diag_output(char *buf
, acx_device_t
* adev
)
855 unsigned int len
= 0, partlen
;
861 fw_stats_t
*fw_stats
;
862 char *part_str
= NULL
;
863 fw_stats_tx_t
*tx
= NULL
;
864 fw_stats_rx_t
*rx
= NULL
;
865 fw_stats_dma_t
*dma
= NULL
;
866 fw_stats_irq_t
*irq
= NULL
;
867 fw_stats_wep_t
*wep
= NULL
;
868 fw_stats_pwr_t
*pwr
= NULL
;
869 fw_stats_mic_t
*mic
= NULL
;
870 fw_stats_aes_t
*aes
= NULL
;
871 fw_stats_event_t
*evt
= NULL
;
875 acx_lock(adev
, flags
);
878 p
= acxpci_s_proc_diag_output(p
, adev
);
882 "** network status **\n"
883 "dev_state_mask 0x%04X\n"
884 "mode %u, channel %u, "
885 "reg_dom_id 0x%02X, reg_dom_chanmask 0x%04X, ",
886 adev
->dev_state_mask
,
887 adev
->mode
, adev
->channel
,
888 adev
->reg_dom_id
, adev
->reg_dom_chanmask
);
890 "ESSID \"%s\", essid_active %d, essid_len %d, "
891 "essid_for_assoc \"%s\", nick \"%s\"\n"
892 "WEP ena %d, restricted %d, idx %d\n",
893 adev
->essid
, adev
->essid_active
, (int)adev
->essid_len
,
894 adev
->essid_for_assoc
, adev
->nick
,
895 adev
->wep_enabled
, adev
->wep_restricted
,
896 adev
->wep_current_index
);
897 p
+= sprintf(p
, "dev_addr " MACSTR
"\n", MAC(adev
->dev_addr
));
898 p
+= sprintf(p
, "bssid " MACSTR
"\n", MAC(adev
->bssid
));
899 p
+= sprintf(p
, "ap_filter " MACSTR
"\n", MAC(adev
->ap
));
901 p
+= sprintf(p
, "\n" "** PHY status **\n"
902 "tx_disabled %d, tx_level_dbm %d\n" /* "tx_level_val %d, tx_level_auto %d\n" */
903 "sensitivity %d, antenna 0x%02X, ed_threshold %d, cca %d, preamble_mode %d\n"
904 "rate_basic 0x%04X, rate_oper 0x%04X\n"
905 "rts_threshold %d, frag_threshold %d, short_retry %d, long_retry %d\n"
906 "msdu_lifetime %d, listen_interval %d, beacon_interval %d\n",
907 adev
->tx_disabled
, adev
->tx_level_dbm
, /* adev->tx_level_val, adev->tx_level_auto, */
908 adev
->sensitivity
, adev
->antenna
, adev
->ed_threshold
,
909 adev
->cca
, adev
->preamble_mode
, adev
->rate_basic
, adev
->rate_oper
, adev
->rts_threshold
,
910 adev
->frag_threshold
, adev
->short_retry
, adev
->long_retry
,
911 adev
->msdu_lifetime
, adev
->listen_interval
,
912 adev
->beacon_interval
);
914 acx_unlock(adev
, flags
);
919 "NOTE: version dependent statistics layout, "
920 "please report if you suspect wrong parsing!\n"
921 "\n" "version \"%s\"\n", adev
->firmware_version
);
923 /* TODO: may replace kmalloc/memset with kzalloc once
924 * Linux 2.6.14 is widespread */
925 fw_stats
= kmalloc(sizeof(*fw_stats
), GFP_KERNEL
);
930 memset(fw_stats
, 0, sizeof(*fw_stats
));
932 st
= (u8
*) fw_stats
;
934 part_str
= "statistics query command";
936 if (OK
!= acx_s_interrogate(adev
, st
, ACX1xx_IE_FIRMWARE_STATISTICS
))
942 if (len
> sizeof(*fw_stats
)) {
944 "firmware version with bigger fw_stats struct detected\n"
945 "(%u vs. %u), please report\n", len
,
947 if (len
> sizeof(*fw_stats
)) {
948 p
+= sprintf(p
, "struct size exceeded allocation!\n");
949 len
= sizeof(*fw_stats
);
953 st_end
= st
- 2 * sizeof(u16
) + len
;
956 /* let's make one bold assumption here:
957 * (hopefully!) *all* statistics fields are u32 only,
958 * thus if we need to make endianness corrections
959 * we can simply do them in one go, in advance */
960 st2
= (u8
*) fw_stats
;
961 for (temp1
= 0; temp1
< len
; temp1
+= 4, st2
+= 4)
962 *(u32
*) st2
= le32_to_cpu(*(u32
*) st2
);
967 /* directly at end of a struct part? --> no error! */
971 tx
= (fw_stats_tx_t
*) st
;
972 st
+= sizeof(fw_stats_tx_t
);
973 rx
= (fw_stats_rx_t
*) st
;
974 st
+= sizeof(fw_stats_rx_t
);
975 partlen
= sizeof(fw_stats_tx_t
) + sizeof(fw_stats_rx_t
);
977 if (IS_ACX100(adev
)) {
978 /* at least ACX100 PCI F/W 1.9.8.b
979 * and ACX100 USB F/W 1.0.7-USB
980 * don't have those two fields... */
981 st
-= 2 * sizeof(u32
);
983 /* our parsing doesn't quite match this firmware yet,
987 temp1
= temp2
= 999999999;
991 temp1
= rx
->rx_aci_events
;
992 temp2
= rx
->rx_aci_resets
;
997 " tx_desc_overfl %u\n"
998 " rx_OutOfMem %u, rx_hdr_overfl %u, rx_hw_stuck %u\n"
999 " rx_dropped_frame %u, rx_frame_ptr_err %u, rx_xfr_hint_trig %u\n"
1000 " rx_aci_events %u, rx_aci_resets %u\n",
1006 rx
->rx_dropped_frame
,
1007 rx
->rx_frame_ptr_err
, rx
->rx_xfr_hint_trig
, temp1
, temp2
);
1014 dma
= (fw_stats_dma_t
*) st
;
1015 partlen
= sizeof(fw_stats_dma_t
);
1023 " rx_dma_req %u, rx_dma_err %u, tx_dma_req %u, tx_dma_err %u\n",
1026 dma
->rx_dma_err
, dma
->tx_dma_req
, dma
->tx_dma_err
);
1033 irq
= (fw_stats_irq_t
*) st
;
1034 partlen
= sizeof(fw_stats_irq_t
);
1042 " cmd_cplt %u, fiq %u\n"
1043 " rx_hdrs %u, rx_cmplt %u, rx_mem_overfl %u, rx_rdys %u\n"
1044 " irqs %u, tx_procs %u, decrypt_done %u\n"
1045 " dma_0_done %u, dma_1_done %u, tx_exch_complet %u\n"
1046 " commands %u, rx_procs %u, hw_pm_mode_changes %u\n"
1047 " host_acks %u, pci_pm %u, acm_wakeups %u\n",
1060 irq
->tx_exch_complet
,
1063 irq
->hw_pm_mode_changes
,
1064 irq
->host_acks
, irq
->pci_pm
, irq
->acm_wakeups
);
1071 wep
= (fw_stats_wep_t
*) st
;
1072 partlen
= sizeof(fw_stats_wep_t
);
1075 if ((IS_PCI(adev
) && IS_ACX100(adev
))
1076 || (IS_USB(adev
) && IS_ACX100(adev
))
1078 /* at least ACX100 PCI F/W 1.9.8.b
1079 * and ACX100 USB F/W 1.0.7-USB
1080 * don't have those two fields... */
1081 st
-= 2 * sizeof(u32
);
1084 temp1
= temp2
= 999999999;
1088 temp1
= wep
->wep_pkt_decrypt
;
1089 temp2
= wep
->wep_decrypt_irqs
;
1094 " wep_key_count %u, wep_default_key_count %u, dot11_def_key_mib %u\n"
1095 " wep_key_not_found %u, wep_decrypt_fail %u\n"
1096 " wep_pkt_decrypt %u, wep_decrypt_irqs %u\n",
1099 wep
->wep_default_key_count
,
1100 wep
->dot11_def_key_mib
,
1101 wep
->wep_key_not_found
,
1102 wep
->wep_decrypt_fail
, temp1
, temp2
);
1109 pwr
= (fw_stats_pwr_t
*) st
;
1110 partlen
= sizeof(fw_stats_pwr_t
);
1118 " tx_start_ctr %u, no_ps_tx_too_short %u\n"
1119 " rx_start_ctr %u, no_ps_rx_too_short %u\n"
1120 " lppd_started %u\n"
1121 " no_lppd_too_noisy %u, no_lppd_too_short %u, no_lppd_matching_frame %u\n",
1124 pwr
->no_ps_tx_too_short
,
1126 pwr
->no_ps_rx_too_short
,
1128 pwr
->no_lppd_too_noisy
,
1129 pwr
->no_lppd_too_short
, pwr
->no_lppd_matching_frame
);
1136 mic
= (fw_stats_mic_t
*) st
;
1137 partlen
= sizeof(fw_stats_mic_t
);
1145 " mic_rx_pkts %u, mic_calc_fail %u\n",
1146 part_str
, mic
->mic_rx_pkts
, mic
->mic_calc_fail
);
1153 aes
= (fw_stats_aes_t
*) st
;
1154 partlen
= sizeof(fw_stats_aes_t
);
1162 " aes_enc_fail %u, aes_dec_fail %u\n"
1163 " aes_enc_pkts %u, aes_dec_pkts %u\n"
1164 " aes_enc_irq %u, aes_dec_irq %u\n",
1169 aes
->aes_dec_pkts
, aes
->aes_enc_irq
, aes
->aes_dec_irq
);
1176 evt
= (fw_stats_event_t
*) st
;
1177 partlen
= sizeof(fw_stats_event_t
);
1185 " heartbeat %u, calibration %u\n"
1186 " rx_mismatch %u, rx_mem_empty %u, rx_pool %u\n"
1188 " phy_tx_err %u, tx_stuck %u\n",
1195 evt
->oom_late
, evt
->phy_tx_err
, evt
->tx_stuck
);
1198 goto fw_stats_bigger
;
1205 "failed at %s part (size %u), offset %u (struct size %u), "
1206 "please report\n", part_str
, partlen
,
1207 (int)((void *)st
- (void *)fw_stats
), len
);
1210 for (; st
< st_end
; st
+= 4)
1213 (int)((void *)st
- (void *)fw_stats
), *(u32
*) st
);
1223 /***********************************************************************
1225 static int acx_s_proc_phy_output(char *buf
, acx_device_t
* adev
)
1233 if (RADIO_RFMD_11 != adev->radio_type) {
1234 printk("sorry, not yet adapted for radio types "
1235 "other than RFMD, please verify "
1236 "PHY size etc. first!\n");
1241 /* The PHY area is only 0x80 bytes long; further pages after that
1242 * only have some page number registers with altered value,
1243 * all other registers remain the same. */
1244 for (i
= 0; i
< 0x80; i
++) {
1245 acx_s_read_phy_reg(adev
, i
, p
++);
1253 /***********************************************************************
1254 ** acx_e_read_proc_XXXX
1255 ** Handle our /proc entry
1258 ** standard kernel read_proc interface
1260 ** number of bytes written to buf
1265 acx_e_read_proc(char *buf
, char **start
, off_t offset
, int count
,
1266 int *eof
, void *data
)
1268 acx_device_t
*adev
= (acx_device_t
*) data
;
1269 unsigned long flags
;
1275 acx_lock(adev
, flags
);
1277 length
= acx_l_proc_output(buf
, adev
);
1278 acx_unlock(adev
, flags
);
1279 acx_sem_unlock(adev
);
1282 if (length
<= offset
+ count
)
1284 *start
= buf
+ offset
;
1295 acx_e_read_proc_diag(char *buf
, char **start
, off_t offset
, int count
,
1296 int *eof
, void *data
)
1298 acx_device_t
*adev
= (acx_device_t
*) data
;
1305 length
= acx_s_proc_diag_output(buf
, adev
);
1306 acx_sem_unlock(adev
);
1309 if (length
<= offset
+ count
)
1311 *start
= buf
+ offset
;
1322 acx_e_read_proc_eeprom(char *buf
, char **start
, off_t offset
, int count
,
1323 int *eof
, void *data
)
1325 acx_device_t
*adev
= (acx_device_t
*) data
;
1334 length
= acxpci_proc_eeprom_output(buf
, adev
);
1335 acx_sem_unlock(adev
);
1339 if (length
<= offset
+ count
)
1341 *start
= buf
+ offset
;
1352 acx_e_read_proc_phy(char *buf
, char **start
, off_t offset
, int count
,
1353 int *eof
, void *data
)
1355 acx_device_t
*adev
= (acx_device_t
*) data
;
1362 length
= acx_s_proc_phy_output(buf
, adev
);
1363 acx_sem_unlock(adev
);
1366 if (length
<= offset
+ count
)
1368 *start
= buf
+ offset
;
1379 /***********************************************************************
1380 ** /proc files registration
1382 static const char *const
1383 proc_files
[] = { "", "_diag", "_eeprom", "_phy" };
1385 static read_proc_t
*const
1388 acx_e_read_proc_diag
,
1389 acx_e_read_proc_eeprom
,
1393 static int manage_proc_entries(struct ieee80211_hw
*hw
, int remove
)
1395 acx_device_t
*adev
= ieee2adev(hw
);
1401 for (i
= 0; i
< ARRAY_SIZE(proc_files
); i
++) {
1402 snprintf(procbuf
, sizeof(procbuf
),
1403 "driver/acx%s", proc_files
[i
]);
1404 log(L_INIT
, "%sing /proc entry %s\n",
1405 remove
? "remov" : "creat", procbuf
);
1407 if (!create_proc_read_entry
1408 (procbuf
, 0, NULL
, proc_funcs
[i
], adev
)) {
1409 printk("acx: cannot register /proc entry %s\n",
1415 remove_proc_entry(procbuf
, NULL
);
1422 int acx_proc_register_entries(struct ieee80211_hw
*ieee
)
1424 return manage_proc_entries(ieee
, 0);
1427 int acx_proc_unregister_entries(struct ieee80211_hw
*ieee
)
1429 return manage_proc_entries(ieee
, 1);
1431 #endif /* CONFIG_PROC_FS */
1434 ** Gathered From rt2x00 and bcm43xx_mac80211 projects
1436 void acx_free_modes(acx_device_t
* adev
)
1439 // kfree(adev->modes);
1440 // adev->modes = NULL;
1444 #define RATETAB_ENT(_rate, _rateid, _flags) \
1448 .val2 = (_rateid), \
1449 .flags = (_flags), \
1453 static struct ieee80211_rate __acx_rates
[] = {
1456 .flags
= IEEE80211_RATE_CCK
},
1459 .flags
= IEEE80211_RATE_CCK_2
},
1462 .flags
= IEEE80211_RATE_CCK_2
},
1465 .flags
= IEEE80211_RATE_CCK_2
},
1468 .flags
= IEEE80211_RATE_OFDM
},
1471 .flags
= IEEE80211_RATE_OFDM
},
1474 .flags
= IEEE80211_RATE_OFDM
},
1477 .flags
= IEEE80211_RATE_OFDM
},
1480 .flags
= IEEE80211_RATE_OFDM
},
1483 .flags
= IEEE80211_RATE_OFDM
},
1486 .flags
= IEEE80211_RATE_OFDM
},
1489 .flags
= IEEE80211_RATE_OFDM
},
1492 #define acx_b_ratetable (__acx_rates + 0)
1493 #define acx_g_ratetable (__acx_rates + 0)
1496 #define CHANTAB_ENT(_chanid, _freq) \
1498 .chan = (_chanid), \
1501 .flag = IEEE80211_CHAN_W_SCAN | \
1502 IEEE80211_CHAN_W_ACTIVE_SCAN | \
1503 IEEE80211_CHAN_W_IBSS, \
1504 .power_level = 0xf, \
1505 .antenna_max = 0xFF, \
1508 static struct ieee80211_channel channels
[] = {
1538 static int acx_setup_modes_bphy(acx_device_t * adev)
1541 struct ieee80211_hw *hw = adev->ieee;
1542 struct ieee80211_hw_mode *mode;
1546 mode = &adev->modes[0];
1547 mode->mode = MODE_IEEE80211B;
1548 mode->num_channels = acx_chantable_size;
1549 mode->channels = channels;
1550 mode->num_rates = acx_b_ratetable_size;
1551 mode->rates = acx_b_ratetable;
1552 err = ieee80211_register_hwmode(hw,mode);
1558 static int acx_setup_modes_gphy(acx_device_t * adev)
1561 struct ieee80211_hw *hw = adev->ieee;
1562 struct ieee80211_hw_mode *mode;
1566 mode = &adev->modes[1];
1567 mode->mode = MODE_IEEE80211G;
1568 mode->num_channels = acx_chantable_size;
1569 mode->channels = channels;
1570 mode->num_rates = acx_g_ratetable_size;
1571 mode->rates = acx_g_ratetable;
1572 err = ieee80211_register_hwmode(hw,mode);
1579 int acx_setup_modes(acx_device_t
* adev
)
1581 struct ieee80211_hw
*hw
= adev
->ieee
;
1582 struct ieee80211_hw_mode
*mode
;
1587 if (IS_ACX111(adev
)) {
1589 adev->modes = kzalloc(sizeof(struct ieee80211_hw_mode) * 2, GFP_KERNEL);
1590 err = acx_setup_modes_gphy(adev);
1592 mode
= &adev
->modes
[0];
1594 /* from the zd1211rw driver: - do we need to do the same? */
1596 memcpy(mode->channels, channels, sizeof(channels));
1597 memcpy(mode->rates, __acx_rates, sizeof(__acx_rates));
1600 mode
->mode
= MODE_IEEE80211G
;
1601 mode
->num_channels
= ARRAY_SIZE(channels
);
1602 mode
->num_rates
= 12;
1603 mode
->rates
= acx_g_ratetable
;
1606 adev->modes = kzalloc(sizeof(struct ieee80211_hw_mode), GFP_KERNEL);
1607 err = acx_setup_modes_bphy(adev);
1609 mode
= &adev
->modes
[1];
1611 /* from the zd1211rw driver: - do we need to do the same? */
1613 memcpy(mode->channels, channels, sizeof(channels));
1614 memcpy(mode->rates, __acx_rates, sizeof(__acx_rates));
1617 mode
->mode
= MODE_IEEE80211B
;
1618 mode
->num_channels
= ARRAY_SIZE(channels
);
1619 mode
->num_rates
= 4;
1620 mode
->rates
= acx_b_ratetable
;
1623 /* if (err && adev->modes)
1624 kfree(adev->modes);*/
1626 mode
->channels
= channels
;
1627 err
= ieee80211_register_hwmode(hw
,mode
);
1634 /***********************************************************************
1635 ** acx_fill_beacon_or_proberesp_template
1637 ** Origin: derived from rt2x00 project
1640 acx_fill_beacon_or_proberesp_template(acx_device_t
*adev
,
1641 struct acx_template_beacon
*templ
,
1642 struct sk_buff
* skb
/* in host order! */)
1646 memcpy(templ
,skb
->data
, skb
->len
);
1651 /***********************************************************************
1652 ** acx_s_set_beacon_template
1657 acx_s_set_beacon_template(acx_device_t
*adev
, struct sk_buff
*skb
)
1659 struct acx_template_beacon bcn
;
1663 printk("Size of template: %08X, Size of beacon: %08X\n",sizeof(struct acx_template_beacon
),skb
->len
);
1664 len
= acx_fill_beacon_or_proberesp_template(adev
, &bcn
, skb
);
1665 result
= acx_s_issue_cmd(adev
, ACX1xx_CMD_CONFIG_BEACON
, &bcn
, len
);
1671 /***********************************************************************
1672 ** acx_cmd_join_bssid
1674 ** Common code for both acx100 and acx111.
1676 /* NB: does NOT match RATE100_nn but matches ACX[111]_SCAN_RATE_n */
1677 static const u8 bitpos2genframe_txrate
[] = {
1678 10, /* 0. 1 Mbit/s */
1679 20, /* 1. 2 Mbit/s */
1680 55, /* 2. 5.5 Mbit/s */
1681 0x0B, /* 3. 6 Mbit/s */
1682 0x0F, /* 4. 9 Mbit/s */
1683 110, /* 5. 11 Mbit/s */
1684 0x0A, /* 6. 12 Mbit/s */
1685 0x0E, /* 7. 18 Mbit/s */
1686 220, /* 8. 22 Mbit/s */
1687 0x09, /* 9. 24 Mbit/s */
1688 0x0D, /* 10. 36 Mbit/s */
1689 0x08, /* 11. 48 Mbit/s */
1690 0x0C, /* 12. 54 Mbit/s */
1691 10, /* 13. 1 Mbit/s, should never happen */
1692 10, /* 14. 1 Mbit/s, should never happen */
1693 10, /* 15. 1 Mbit/s, should never happen */
1697 ** Actually, each one compiled into one AND and one SHIFT,
1698 ** 31 bytes in x86 asm (more if uints are replaced by u16/u8) */
1699 static inline unsigned int rate111to5bits(unsigned int rate
)
1702 | ((rate
& RATE111_11
) / (RATE111_11
/ JOINBSS_RATES_11
))
1703 | ((rate
& RATE111_22
) / (RATE111_22
/ JOINBSS_RATES_22
));
1707 void acx_s_cmd_join_bssid(acx_device_t
*adev
, const u8
*bssid
)
1713 if (mac_is_zero(bssid
))
1718 dtim_interval
= (ACX_MODE_0_ADHOC
== adev
->mode
) ?
1719 1 : adev
->dtim_interval
;
1721 memset(&tmp
, 0, sizeof(tmp
));
1723 for (i
= 0; i
< ETH_ALEN
; i
++) {
1724 tmp
.bssid
[i
] = bssid
[ETH_ALEN
-1 - i
];
1727 tmp
.beacon_interval
= cpu_to_le16(adev
->beacon_interval
);
1729 /* Basic rate set. Control frame responses (such as ACK or CTS frames)
1730 ** are sent with one of these rates */
1731 if (IS_ACX111(adev
)) {
1732 /* It was experimentally determined that rates_basic
1733 ** can take 11g rates as well, not only rates
1734 ** defined with JOINBSS_RATES_BASIC111_nnn.
1735 ** Just use RATE111_nnn constants... */
1736 tmp
.u
.acx111
.dtim_interval
= dtim_interval
;
1737 tmp
.u
.acx111
.rates_basic
= cpu_to_le16(adev
->rate_basic
);
1738 log(L_ASSOC
, "rates_basic:%04X, rates_supported:%04X\n",
1739 adev
->rate_basic
, adev
->rate_oper
);
1741 tmp
.u
.acx100
.dtim_interval
= dtim_interval
;
1742 tmp
.u
.acx100
.rates_basic
= rate111to5bits(adev
->rate_basic
);
1743 tmp
.u
.acx100
.rates_supported
= rate111to5bits(adev
->rate_oper
);
1744 log(L_ASSOC
, "rates_basic:%04X->%02X, "
1745 "rates_supported:%04X->%02X\n",
1746 adev
->rate_basic
, tmp
.u
.acx100
.rates_basic
,
1747 adev
->rate_oper
, tmp
.u
.acx100
.rates_supported
);
1750 /* Setting up how Beacon, Probe Response, RTS, and PS-Poll frames
1751 ** will be sent (rate/modulation/preamble) */
1752 tmp
.genfrm_txrate
= bitpos2genframe_txrate
[lowest_bit(adev
->rate_basic
)];
1753 tmp
.genfrm_mod_pre
= 0; /* FIXME: was = adev->capab_short (which was always 0); */
1754 /* we can use short pre *if* all peers can understand it */
1755 /* FIXME #2: we need to correctly set PBCC/OFDM bits here too */
1757 /* we switch fw to STA mode in MONITOR mode, it seems to be
1758 ** the only mode where fw does not emit beacons by itself
1759 ** but allows us to send anything (we really want to retain
1760 ** ability to tx arbitrary frames in MONITOR mode)
1762 tmp
.macmode
= (adev
->mode
!= ACX_MODE_MONITOR
? adev
->mode
: ACX_MODE_2_STA
);
1763 tmp
.channel
= adev
->channel
;
1764 tmp
.essid_len
= adev
->essid_len
;
1766 memcpy(tmp
.essid
, adev
->essid
, tmp
.essid_len
);
1767 acx_s_issue_cmd(adev
, ACX1xx_CMD_JOIN
, &tmp
, tmp
.essid_len
+ 0x11);
1769 log(L_ASSOC
|L_DEBUG
, "BSS_Type = %u\n", tmp
.macmode
);
1770 acxlog_mac(L_ASSOC
|L_DEBUG
, "JoinBSSID MAC:", adev
->bssid
, "\n");
1772 /* acx_update_capabilities(adev); */
1776 /***********************************************************************
1777 ** acxpci_i_set_multicast_list
1778 ** FIXME: most likely needs refinement
1781 void acx_i_set_multicast_list(struct ieee80211_hw
*hw
,
1782 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1783 unsigned short netflags
, int mc_count
)
1785 unsigned int changed_flags
,
1786 unsigned int *total_flags
,
1787 int mc_count
, struct dev_addr_list
*mc_list
)
1790 acx_device_t
*adev
= ieee2adev(hw
);
1791 unsigned long flags
;
1795 acx_lock(adev
, flags
);
1797 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
1798 changed_flags
&= (FIF_PROMISC_IN_BSS
| FIF_ALLMULTI
| FIF_FCSFAIL
|
1799 FIF_CONTROL
| FIF_OTHER_BSS
);
1800 *total_flags
&= (FIF_PROMISC_IN_BSS
| FIF_ALLMULTI
| FIF_FCSFAIL
|
1801 FIF_CONTROL
| FIF_OTHER_BSS
);
1802 /* if ((changed_flags & (FIF_PROMISC_IN_BSS | FIF_ALLMULTI)) == 0)
1806 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1807 if (netflags
& (IFF_PROMISC
| IFF_ALLMULTI
)) {
1811 SET_BIT(adev
->rx_config_1
, RX_CFG1_RCV_PROMISCUOUS
);
1812 CLEAR_BIT(adev
->rx_config_1
, RX_CFG1_FILTER_ALL_MULTI
);
1813 SET_BIT(adev
->set_mask
, SET_RXCONFIG
);
1814 /* let kernel know in case *we* needed to set promiscuous */
1816 CLEAR_BIT(adev
->rx_config_1
, RX_CFG1_RCV_PROMISCUOUS
);
1817 SET_BIT(adev
->rx_config_1
, RX_CFG1_FILTER_ALL_MULTI
);
1818 SET_BIT(adev
->set_mask
, SET_RXCONFIG
);
1821 /* cannot update card settings directly here, atomic context */
1822 acx_schedule_task(adev
, ACX_AFTER_IRQ_UPDATE_CARD_CFG
);
1824 acx_unlock(adev
, flags
);
1829 /***********************************************************************
1830 ** acx111 feature config
1835 acx111_s_get_feature_config(acx_device_t
* adev
,
1836 u32
* feature_options
, u32
* data_flow_options
)
1838 struct acx111_ie_feature_config feat
;
1842 if (!IS_ACX111(adev
)) {
1846 memset(&feat
, 0, sizeof(feat
));
1848 if (OK
!= acx_s_interrogate(adev
, &feat
, ACX1xx_IE_FEATURE_CONFIG
)) {
1853 "got Feature option:0x%X, DataFlow option: 0x%X\n",
1854 feat
.feature_options
, feat
.data_flow_options
);
1856 if (feature_options
)
1857 *feature_options
= le32_to_cpu(feat
.feature_options
);
1858 if (data_flow_options
)
1859 *data_flow_options
= le32_to_cpu(feat
.data_flow_options
);
1867 acx111_s_set_feature_config(acx_device_t
* adev
,
1868 u32 feature_options
, u32 data_flow_options
,
1870 /* 0 == remove, 1 == add, 2 == set */ )
1872 struct acx111_ie_feature_config feat
;
1876 if (!IS_ACX111(adev
)) {
1881 if ((mode
< 0) || (mode
> 2)) {
1887 /* need to modify old data */
1888 acx111_s_get_feature_config(adev
, &feat
.feature_options
,
1889 &feat
.data_flow_options
);
1891 /* need to set a completely new value */
1892 feat
.feature_options
= 0;
1893 feat
.data_flow_options
= 0;
1896 if (mode
== 0) { /* remove */
1897 CLEAR_BIT(feat
.feature_options
, cpu_to_le32(feature_options
));
1898 CLEAR_BIT(feat
.data_flow_options
,
1899 cpu_to_le32(data_flow_options
));
1900 } else { /* add or set */
1901 SET_BIT(feat
.feature_options
, cpu_to_le32(feature_options
));
1902 SET_BIT(feat
.data_flow_options
, cpu_to_le32(data_flow_options
));
1906 "old: feature 0x%08X dataflow 0x%08X. mode: %u\n"
1907 "new: feature 0x%08X dataflow 0x%08X\n",
1908 feature_options
, data_flow_options
, mode
,
1909 le32_to_cpu(feat
.feature_options
),
1910 le32_to_cpu(feat
.data_flow_options
));
1912 if (OK
!= acx_s_configure(adev
, &feat
, ACX1xx_IE_FEATURE_CONFIG
)) {
1921 static inline int acx111_s_feature_off(acx_device_t
* adev
, u32 f
, u32 d
)
1923 return acx111_s_set_feature_config(adev
, f
, d
, 0);
1925 static inline int acx111_s_feature_on(acx_device_t
* adev
, u32 f
, u32 d
)
1927 return acx111_s_set_feature_config(adev
, f
, d
, 1);
1929 static inline int acx111_s_feature_set(acx_device_t
* adev
, u32 f
, u32 d
)
1931 return acx111_s_set_feature_config(adev
, f
, d
, 2);
1935 /***********************************************************************
1936 ** acx100_s_init_memory_pools
1939 acx100_s_init_memory_pools(acx_device_t
* adev
, const acx_ie_memmap_t
* mmt
)
1941 acx100_ie_memblocksize_t MemoryBlockSize
;
1942 acx100_ie_memconfigoption_t MemoryConfigOption
;
1943 int TotalMemoryBlocks
;
1945 int TotalRxBlockSize
;
1947 int TotalTxBlockSize
;
1951 /* Let's see if we can follow this:
1952 first we select our memory block size (which I think is
1953 completely arbitrary) */
1954 MemoryBlockSize
.size
= cpu_to_le16(adev
->memblocksize
);
1956 /* Then we alert the card to our decision of block size */
1957 if (OK
!= acx_s_configure(adev
, &MemoryBlockSize
, ACX100_IE_BLOCK_SIZE
)) {
1961 /* We figure out how many total blocks we can create, using
1962 the block size we chose, and the beginning and ending
1963 memory pointers, i.e.: end-start/size */
1965 (le32_to_cpu(mmt
->PoolEnd
) -
1966 le32_to_cpu(mmt
->PoolStart
)) / adev
->memblocksize
;
1968 log(L_DEBUG
, "TotalMemoryBlocks=%u (%u bytes)\n",
1969 TotalMemoryBlocks
, TotalMemoryBlocks
* adev
->memblocksize
);
1971 /* MemoryConfigOption.DMA_config bitmask:
1972 access to ACX memory is to be done:
1973 0x00080000 using PCI conf space?!
1974 0x00040000 using IO instructions?
1975 0x00000000 using memory access instructions
1976 0x00020000 using local memory block linked list (else what?)
1977 0x00010000 using host indirect descriptors (else host must access ACX memory?)
1980 MemoryConfigOption
.DMA_config
= cpu_to_le32(0x30000);
1981 /* Declare start of the Rx host pool */
1982 MemoryConfigOption
.pRxHostDesc
=
1983 cpu2acx(adev
->rxhostdesc_startphy
);
1984 log(L_DEBUG
, "pRxHostDesc 0x%08X, rxhostdesc_startphy 0x%lX\n",
1985 acx2cpu(MemoryConfigOption
.pRxHostDesc
),
1986 (long)adev
->rxhostdesc_startphy
);
1988 MemoryConfigOption
.DMA_config
= cpu_to_le32(0x20000);
1991 /* 50% of the allotment of memory blocks go to tx descriptors */
1992 TxBlockNum
= TotalMemoryBlocks
/ 2;
1993 MemoryConfigOption
.TxBlockNum
= cpu_to_le16(TxBlockNum
);
1995 /* and 50% go to the rx descriptors */
1996 RxBlockNum
= TotalMemoryBlocks
- TxBlockNum
;
1997 MemoryConfigOption
.RxBlockNum
= cpu_to_le16(RxBlockNum
);
1999 /* size of the tx and rx descriptor queues */
2000 TotalTxBlockSize
= TxBlockNum
* adev
->memblocksize
;
2001 TotalRxBlockSize
= RxBlockNum
* adev
->memblocksize
;
2002 log(L_DEBUG
, "TxBlockNum %u RxBlockNum %u TotalTxBlockSize %u "
2003 "TotalTxBlockSize %u\n", TxBlockNum
, RxBlockNum
,
2004 TotalTxBlockSize
, TotalRxBlockSize
);
2007 /* align the tx descriptor queue to an alignment of 0x20 (32 bytes) */
2008 MemoryConfigOption
.rx_mem
=
2009 cpu_to_le32((le32_to_cpu(mmt
->PoolStart
) + 0x1f) & ~0x1f);
2011 /* align the rx descriptor queue to units of 0x20
2012 * and offset it by the tx descriptor queue */
2013 MemoryConfigOption
.tx_mem
=
2014 cpu_to_le32((le32_to_cpu(mmt
->PoolStart
) + TotalRxBlockSize
+
2016 log(L_DEBUG
, "rx_mem %08X rx_mem %08X\n", MemoryConfigOption
.tx_mem
,
2017 MemoryConfigOption
.rx_mem
);
2019 /* alert the device to our decision */
2021 acx_s_configure(adev
, &MemoryConfigOption
,
2022 ACX1xx_IE_MEMORY_CONFIG_OPTIONS
)) {
2026 /* and tell the device to kick it into gear */
2027 if (OK
!= acx_s_issue_cmd(adev
, ACX100_CMD_INIT_MEMORY
, NULL
, 0)) {
2038 /***********************************************************************
2039 ** acx100_s_create_dma_regions
2041 ** Note that this fn messes up heavily with hardware, but we cannot
2042 ** lock it (we need to sleep). Not a problem since IRQs can't happen
2044 /* OLD CODE? - let's rewrite it! */
2045 static int acx100_s_create_dma_regions(acx_device_t
* adev
)
2047 acx100_ie_queueconfig_t queueconf
;
2048 acx_ie_memmap_t memmap
;
2050 u32 tx_queue_start
, rx_queue_start
;
2054 /* read out the acx100 physical start address for the queues */
2055 if (OK
!= acx_s_interrogate(adev
, &memmap
, ACX1xx_IE_MEMORY_MAP
)) {
2059 tx_queue_start
= le32_to_cpu(memmap
.QueueStart
);
2060 rx_queue_start
= tx_queue_start
+ TX_CNT
* sizeof(txdesc_t
);
2062 log(L_DEBUG
, "initializing Queue Indicator\n");
2064 memset(&queueconf
, 0, sizeof(queueconf
));
2066 /* Not needed for PCI, so we can avoid setting them altogether */
2068 queueconf
.NumTxDesc
= USB_TX_CNT
;
2069 queueconf
.NumRxDesc
= USB_RX_CNT
;
2072 /* calculate size of queues */
2073 queueconf
.AreaSize
= cpu_to_le32(TX_CNT
* sizeof(txdesc_t
) +
2074 RX_CNT
* sizeof(rxdesc_t
) + 8);
2075 queueconf
.NumTxQueues
= 1; /* number of tx queues */
2076 /* sets the beginning of the tx descriptor queue */
2077 queueconf
.TxQueueStart
= memmap
.QueueStart
;
2078 /* done by memset: queueconf.TxQueuePri = 0; */
2079 queueconf
.RxQueueStart
= cpu_to_le32(rx_queue_start
);
2080 queueconf
.QueueOptions
= 1; /* auto reset descriptor */
2081 /* sets the end of the rx descriptor queue */
2082 queueconf
.QueueEnd
=
2083 cpu_to_le32(rx_queue_start
+ RX_CNT
* sizeof(rxdesc_t
)
2085 /* sets the beginning of the next queue */
2086 queueconf
.HostQueueEnd
=
2087 cpu_to_le32(le32_to_cpu(queueconf
.QueueEnd
) + 8);
2088 if (OK
!= acx_s_configure(adev
, &queueconf
, ACX1xx_IE_QUEUE_CONFIG
)) {
2093 /* sets the beginning of the rx descriptor queue, after the tx descrs */
2094 if (OK
!= acxpci_s_create_hostdesc_queues(adev
))
2096 acxpci_create_desc_queues(adev
, tx_queue_start
, rx_queue_start
);
2099 if (OK
!= acx_s_interrogate(adev
, &memmap
, ACX1xx_IE_MEMORY_MAP
)) {
2103 memmap
.PoolStart
= cpu_to_le32((le32_to_cpu(memmap
.QueueEnd
) + 4 +
2106 if (OK
!= acx_s_configure(adev
, &memmap
, ACX1xx_IE_MEMORY_MAP
)) {
2110 if (OK
!= acx100_s_init_memory_pools(adev
, &memmap
)) {
2118 acx_s_mwait(1000); /* ? */
2120 acxpci_free_desc_queues(adev
);
2127 /***********************************************************************
2128 ** acx111_s_create_dma_regions
2130 ** Note that this fn messes heavily with hardware, but we cannot
2131 ** lock it (we need to sleep). Not a problem since IRQs can't happen
2133 #define ACX111_PERCENT(percent) ((percent)/5)
2135 static int acx111_s_create_dma_regions(acx_device_t
* adev
)
2137 struct acx111_ie_memoryconfig memconf
;
2138 struct acx111_ie_queueconfig queueconf
;
2139 u32 tx_queue_start
, rx_queue_start
;
2143 /* Calculate memory positions and queue sizes */
2145 /* Set up our host descriptor pool + data pool */
2147 if (OK
!= acxpci_s_create_hostdesc_queues(adev
))
2151 memset(&memconf
, 0, sizeof(memconf
));
2152 /* the number of STAs (STA contexts) to support
2153 ** NB: was set to 1 and everything seemed to work nevertheless... */
2154 memconf
.no_of_stations
= 1; //cpu_to_le16(VEC_SIZE(adev->sta_list));
2155 /* specify the memory block size. Default is 256 */
2156 memconf
.memory_block_size
= cpu_to_le16(adev
->memblocksize
);
2157 /* let's use 50%/50% for tx/rx (specify percentage, units of 5%) */
2158 memconf
.tx_rx_memory_block_allocation
= ACX111_PERCENT(50);
2159 /* set the count of our queues
2160 ** NB: struct acx111_ie_memoryconfig shall be modified
2161 ** if we ever will switch to more than one rx and/or tx queue */
2162 memconf
.count_rx_queues
= 1;
2163 memconf
.count_tx_queues
= 1;
2164 /* 0 == Busmaster Indirect Memory Organization, which is what we want
2165 * (using linked host descs with their allocated mem).
2166 * 2 == Generic Bus Slave */
2167 /* done by memset: memconf.options = 0; */
2168 /* let's use 25% for fragmentations and 75% for frame transfers
2169 * (specified in units of 5%) */
2170 memconf
.fragmentation
= ACX111_PERCENT(75);
2171 /* Rx descriptor queue config */
2172 memconf
.rx_queue1_count_descs
= RX_CNT
;
2173 memconf
.rx_queue1_type
= 7; /* must be set to 7 */
2174 /* done by memset: memconf.rx_queue1_prio = 0; low prio */
2176 memconf
.rx_queue1_host_rx_start
=
2177 cpu2acx(adev
->rxhostdesc_startphy
);
2179 /* Tx descriptor queue config */
2180 memconf
.tx_queue1_count_descs
= TX_CNT
;
2181 /* done by memset: memconf.tx_queue1_attributes = 0; lowest priority */
2183 /* NB1: this looks wrong: (memconf,ACX1xx_IE_QUEUE_CONFIG),
2184 ** (queueconf,ACX1xx_IE_MEMORY_CONFIG_OPTIONS) look swapped, eh?
2185 ** But it is actually correct wrt IE numbers.
2186 ** NB2: sizeof(memconf) == 28 == 0x1c but configure(ACX1xx_IE_QUEUE_CONFIG)
2187 ** writes 0x20 bytes (because same IE for acx100 uses struct acx100_ie_queueconfig
2188 ** which is 4 bytes larger. what a mess. TODO: clean it up) */
2189 if (OK
!= acx_s_configure(adev
, &memconf
, ACX1xx_IE_QUEUE_CONFIG
)) {
2193 acx_s_interrogate(adev
, &queueconf
, ACX1xx_IE_MEMORY_CONFIG_OPTIONS
);
2195 tx_queue_start
= le32_to_cpu(queueconf
.tx1_queue_address
);
2196 rx_queue_start
= le32_to_cpu(queueconf
.rx1_queue_address
);
2198 log(L_INIT
, "dump queue head (from card):\n"
2200 "tx_memory_block_address: %X\n"
2201 "rx_memory_block_address: %X\n"
2202 "tx1_queue address: %X\n"
2203 "rx1_queue address: %X\n",
2204 le16_to_cpu(queueconf
.len
),
2205 le32_to_cpu(queueconf
.tx_memory_block_address
),
2206 le32_to_cpu(queueconf
.rx_memory_block_address
),
2207 tx_queue_start
, rx_queue_start
);
2210 acxpci_create_desc_queues(adev
, tx_queue_start
, rx_queue_start
);
2216 acxpci_free_desc_queues(adev
);
2223 /***********************************************************************
2225 static void acx_s_initialize_rx_config(acx_device_t
* adev
)
2233 switch (adev
->mode
) {
2234 case ACX_MODE_MONITOR
:
2235 adev
->rx_config_1
= (u16
) (0
2236 /* | RX_CFG1_INCLUDE_RXBUF_HDR */
2237 /* | RX_CFG1_FILTER_SSID */
2238 /* | RX_CFG1_FILTER_BCAST */
2239 /* | RX_CFG1_RCV_MC_ADDR1 */
2240 /* | RX_CFG1_RCV_MC_ADDR0 */
2241 /* | RX_CFG1_FILTER_ALL_MULTI */
2242 /* | RX_CFG1_FILTER_BSSID */
2243 /* | RX_CFG1_FILTER_MAC */
2244 | RX_CFG1_RCV_PROMISCUOUS
2245 | RX_CFG1_INCLUDE_FCS
2246 /* | RX_CFG1_INCLUDE_PHY_HDR */
2248 adev
->rx_config_2
= (u16
) (0
2249 | RX_CFG2_RCV_ASSOC_REQ
2250 | RX_CFG2_RCV_AUTH_FRAMES
2251 | RX_CFG2_RCV_BEACON_FRAMES
2252 | RX_CFG2_RCV_CONTENTION_FREE
2253 | RX_CFG2_RCV_CTRL_FRAMES
2254 | RX_CFG2_RCV_DATA_FRAMES
2255 | RX_CFG2_RCV_BROKEN_FRAMES
2256 | RX_CFG2_RCV_MGMT_FRAMES
2257 | RX_CFG2_RCV_PROBE_REQ
2258 | RX_CFG2_RCV_PROBE_RESP
2259 | RX_CFG2_RCV_ACK_FRAMES
2260 | RX_CFG2_RCV_OTHER
);
2263 adev
->rx_config_1
= (u16
) (0
2264 /* | RX_CFG1_INCLUDE_RXBUF_HDR */
2265 /* | RX_CFG1_FILTER_SSID */
2266 /* | RX_CFG1_FILTER_BCAST */
2267 /* | RX_CFG1_RCV_MC_ADDR1 */
2268 /* | RX_CFG1_RCV_MC_ADDR0 */
2269 /* | RX_CFG1_FILTER_ALL_MULTI */
2270 /* | RX_CFG1_FILTER_BSSID */
2271 /* | RX_CFG1_FILTER_MAC */
2272 | RX_CFG1_RCV_PROMISCUOUS
2273 /* | RX_CFG1_INCLUDE_FCS */
2274 /* | RX_CFG1_INCLUDE_PHY_HDR */
2276 adev
->rx_config_2
= (u16
) (0
2277 | RX_CFG2_RCV_ASSOC_REQ
2278 | RX_CFG2_RCV_AUTH_FRAMES
2279 | RX_CFG2_RCV_BEACON_FRAMES
2280 | RX_CFG2_RCV_CONTENTION_FREE
2281 | RX_CFG2_RCV_CTRL_FRAMES
2282 | RX_CFG2_RCV_DATA_FRAMES
2283 /*| RX_CFG2_RCV_BROKEN_FRAMES */
2284 | RX_CFG2_RCV_MGMT_FRAMES
2285 | RX_CFG2_RCV_PROBE_REQ
2286 | RX_CFG2_RCV_PROBE_RESP
2287 | RX_CFG2_RCV_ACK_FRAMES
2288 | RX_CFG2_RCV_OTHER
);
2291 adev
->rx_config_1
|= RX_CFG1_INCLUDE_RXBUF_HDR
;
2293 if ((adev
->rx_config_1
& RX_CFG1_INCLUDE_PHY_HDR
)
2294 || (adev
->firmware_numver
>= 0x02000000))
2295 adev
->phy_header_len
= IS_ACX111(adev
) ? 8 : 4;
2297 adev
->phy_header_len
= 0;
2299 log(L_INIT
, "setting RXconfig to %04X:%04X\n",
2300 adev
->rx_config_1
, adev
->rx_config_2
);
2301 cfg
.rx_cfg1
= cpu_to_le16(adev
->rx_config_1
);
2302 cfg
.rx_cfg2
= cpu_to_le16(adev
->rx_config_2
);
2303 acx_s_configure(adev
, &cfg
, ACX1xx_IE_RXCONFIG
);
2307 /***********************************************************************
2308 ** FIXME: this should be solved in a general way for all radio types
2309 ** by decoding the radio firmware module,
2310 ** since it probably has some standard structure describing how to
2311 ** set the power level of the radio module which it controls.
2312 ** Or maybe not, since the radio module probably has a function interface
2313 ** instead which then manages Tx level programming :-\
2317 static int acx111_s_set_tx_level(acx_device_t
* adev
, u8 level_dbm
)
2319 struct acx111_ie_tx_level tx_level
;
2321 /* my acx111 card has two power levels in its configoptions (== EEPROM):
2324 * For now, just assume all other acx111 cards have the same.
2325 * FIXME: Ideally we would query it here, but we first need a
2326 * standard way to query individual configoptions easily.
2327 * Well, now we have proper cfgopt txpower variables, but this still
2328 * hasn't been done yet, since it also requires dBm <-> mW conversion here... */
2329 if (level_dbm
<= 12) {
2330 tx_level
.level
= 2; /* 10 dBm */
2331 adev
->tx_level_dbm
= 10;
2333 tx_level
.level
= 1; /* 15 dBm */
2334 adev
->tx_level_dbm
= 15;
2336 if (level_dbm
!= adev
->tx_level_dbm
)
2337 log(L_INIT
, "acx111 firmware has specific "
2338 "power levels only: adjusted %d dBm to %d dBm!\n",
2339 level_dbm
, adev
->tx_level_dbm
);
2341 return acx_s_configure(adev
, &tx_level
, ACX1xx_IE_DOT11_TX_POWER_LEVEL
);
2344 static int acx_s_set_tx_level(acx_device_t
*adev
, u8 level_dbm
)
2346 if (IS_ACX111(adev
)) {
2347 return acx111_s_set_tx_level(adev
, level_dbm
);
2350 return acx100pci_s_set_tx_level(adev
, level_dbm
);
2357 /***********************************************************************
2358 ** acx_s_set_defaults
2360 void acx_s_set_defaults(acx_device_t
* adev
)
2362 struct ieee80211_conf
*conf
= &adev
->ieee
->conf
;
2363 unsigned long flags
;
2367 acx_lock(adev
, flags
);
2368 /* do it before getting settings, prevent bogus channel 0 warning */
2371 /* query some settings from the card.
2372 * NOTE: for some settings, e.g. CCA and ED (ACX100!), an initial
2373 * query is REQUIRED, otherwise the card won't work correctly! */
2375 GETSET_ANTENNA
| GETSET_SENSITIVITY
| GETSET_STATION_ID
|
2377 /* Only ACX100 supports ED and CCA */
2378 if (IS_ACX100(adev
))
2379 adev
->get_mask
|= GETSET_CCA
| GETSET_ED_THRESH
;
2381 acx_s_update_card_settings(adev
);
2384 /* set our global interrupt mask */
2386 acxpci_set_interrupt_mask(adev
);
2388 adev
->led_power
= 1; /* LED is active on startup */
2389 adev
->brange_max_quality
= 60; /* LED blink max quality is 60 */
2390 adev
->brange_time_last_state_change
= jiffies
;
2392 /* copy the MAC address we just got from the card
2393 * into our MAC address used during current 802.11 session */
2394 SET_IEEE80211_PERM_ADDR(adev
->ieee
, adev
->dev_addr
);
2395 MAC_BCAST(adev
->ap
);
2398 snprintf(adev
->essid
, sizeof(adev
->essid
), "STA%02X%02X%02X",
2399 adev
->dev_addr
[3], adev
->dev_addr
[4], adev
->dev_addr
[5]);
2400 adev
->essid_active
= 1;
2402 /* we have a nick field to waste, so why not abuse it
2403 * to announce the driver version? ;-) */
2404 strncpy(adev
->nick
, "acx " ACX_RELEASE
, IW_ESSID_MAX_SIZE
);
2406 if (IS_PCI(adev
)) { /* FIXME: this should be made to apply to USB, too! */
2407 /* first regulatory domain entry in EEPROM == default reg. domain */
2408 adev
->reg_dom_id
= adev
->cfgopt_domains
.list
[0];
2411 /* 0xffff would be better, but then we won't get a "scan complete"
2412 * interrupt, so our current infrastructure will fail: */
2413 adev
->scan_count
= 1;
2414 adev
->scan_mode
= ACX_SCAN_OPT_ACTIVE
;
2415 adev
->scan_duration
= 100;
2416 adev
->scan_probe_delay
= 200;
2417 /* reported to break scanning: adev->scan_probe_delay = adev->cfgopt_probe_delay; */
2418 adev
->scan_rate
= ACX_SCAN_RATE_1
;
2421 adev
->mode
= ACX_MODE_2_STA
;
2422 adev
->listen_interval
= 100;
2423 adev
->beacon_interval
= DEFAULT_BEACON_INTERVAL
;
2424 adev
->dtim_interval
= DEFAULT_DTIM_INTERVAL
;
2426 adev
->msdu_lifetime
= DEFAULT_MSDU_LIFETIME
;
2428 adev
->rts_threshold
= DEFAULT_RTS_THRESHOLD
;
2429 adev
->frag_threshold
= 2346;
2431 /* use standard default values for retry limits */
2432 adev
->short_retry
= 7; /* max. retries for (short) non-RTS packets */
2433 adev
->long_retry
= 4; /* max. retries for long (RTS) packets */
2435 adev
->preamble_mode
= 2; /* auto */
2436 adev
->fallback_threshold
= 3;
2437 adev
->stepup_threshold
= 10;
2438 adev
->rate_bcast
= RATE111_1
;
2439 adev
->rate_bcast100
= RATE100_1
;
2440 adev
->rate_basic
= RATE111_1
| RATE111_2
;
2441 adev
->rate_auto
= 1;
2442 if (IS_ACX111(adev
)) {
2443 adev
->rate_oper
= RATE111_ALL
;
2445 adev
->rate_oper
= RATE111_ACX100_COMPAT
;
2448 /* Supported Rates element - the rates here are given in units of
2449 * 500 kbit/s, plus 0x80 added. See 802.11-1999.pdf item 7.3.2.2 */
2450 acx_l_update_ratevector(adev
);
2452 /* set some more defaults */
2453 if (IS_ACX111(adev
)) {
2454 /* 30mW (15dBm) is default, at least in my acx111 card: */
2455 adev
->tx_level_dbm
= 15;
2456 conf
->power_level
= adev
->tx_level_dbm
;
2457 acx_s_set_tx_level(adev
, adev
->tx_level_dbm
);
2458 SET_BIT(adev
->set_mask
, GETSET_TXPOWER
);
2460 /* don't use max. level, since it might be dangerous
2461 * (e.g. WRT54G people experience
2462 * excessive Tx power damage!) */
2463 adev
->tx_level_dbm
= 18;
2464 conf
->power_level
= adev
->tx_level_dbm
;
2465 acx_s_set_tx_level(adev
, adev
->tx_level_dbm
);
2466 SET_BIT(adev
->set_mask
, GETSET_TXPOWER
);
2469 /* adev->tx_level_auto = 1; */
2470 if (IS_ACX111(adev
)) {
2471 /* start with sensitivity level 1 out of 3: */
2472 adev
->sensitivity
= 1;
2475 /* #define ENABLE_POWER_SAVE */
2476 #ifdef ENABLE_POWER_SAVE
2477 adev
->ps_wakeup_cfg
= PS_CFG_ENABLE
| PS_CFG_WAKEUP_ALL_BEAC
;
2478 adev
->ps_listen_interval
= 1;
2480 PS_OPT_ENA_ENHANCED_PS
| PS_OPT_TX_PSPOLL
| PS_OPT_STILL_RCV_BCASTS
;
2481 adev
->ps_hangover_period
= 30;
2482 adev
->ps_enhanced_transition_time
= 0;
2484 adev
->ps_wakeup_cfg
= 0;
2485 adev
->ps_listen_interval
= 0;
2486 adev
->ps_options
= 0;
2487 adev
->ps_hangover_period
= 0;
2488 adev
->ps_enhanced_transition_time
= 0;
2491 /* These settings will be set in fw on ifup */
2492 adev
->set_mask
= 0 | GETSET_RETRY
| SET_MSDU_LIFETIME
2493 /* configure card to do rate fallback when in auto rate mode */
2494 | SET_RATE_FALLBACK
| SET_RXCONFIG
| GETSET_TXPOWER
2495 /* better re-init the antenna value we got above */
2497 #if POWER_SAVE_80211
2498 | GETSET_POWER_80211
2502 acx_unlock(adev
, flags
);
2503 acx_lock_unhold(); /* hold time 844814 CPU ticks @2GHz */
2505 acx_s_initialize_rx_config(adev
);
2511 /***********************************************************************
2512 ** acx_l_process_rxbuf
2514 ** NB: used by USB code also
2516 void acx_l_process_rxbuf(acx_device_t
* adev
, rxbuffer_t
* rxbuf
)
2518 struct ieee80211_hdr
*hdr
;
2520 hdr
= acx_get_wlan_hdr(adev
, rxbuf
);
2521 fc
= le16_to_cpu(hdr
->frame_control
);
2522 /* length of frame from control field to first byte of FCS */
2523 buf_len
= RXBUF_BYTES_RCVD(adev
, rxbuf
);
2525 if (unlikely(acx_debug
& L_DATA
)) {
2526 printk("rx: 802.11 buf[%u]: \n", buf_len
);
2527 acx_dump_bytes(hdr
, buf_len
);
2531 acx_l_rx(adev
, rxbuf
);
2532 /* Now check Rx quality level, AFTER processing packet.
2533 * I tried to figure out how to map these levels to dBm
2534 * values, but for the life of me I really didn't
2535 * manage to get it. Either these values are not meant to
2536 * be expressed in dBm, or it's some pretty complicated
2539 #ifdef FROM_SCAN_SOURCE_ONLY
2540 /* only consider packets originating from the MAC
2541 * address of the device that's managing our BSSID.
2542 * Disable it for now, since it removes information (levels
2543 * from different peers) and slows the Rx path. *//*
2544 if (adev->ap_client && mac_is_equal(hdr->a2, adev->ap_client->address)) {
2550 /***********************************************************************
2551 ** acx_l_handle_txrate_auto
2553 ** Theory of operation:
2554 ** client->rate_cap is a bitmask of rates client is capable of.
2555 ** client->rate_cfg is a bitmask of allowed (configured) rates.
2556 ** It is set as a result of iwconfig rate N [auto]
2557 ** or iwpriv set_rates "N,N,N N,N,N" commands.
2558 ** It can be fixed (e.g. 0x0080 == 18Mbit only),
2559 ** auto (0x00ff == 18Mbit or any lower value),
2560 ** and code handles any bitmask (0x1081 == try 54Mbit,18Mbit,1Mbit _only_).
2562 ** client->rate_cur is a value for rate111 field in tx descriptor.
2563 ** It is always set to txrate_cfg sans zero or more most significant
2564 ** bits. This routine handles selection of new rate_cur value depending on
2565 ** outcome of last tx event.
2567 ** client->rate_100 is a precalculated rate value for acx100
2568 ** (we can do without it, but will need to calculate it on each tx).
2570 ** You cannot configure mixed usage of 5.5 and/or 11Mbit rate
2571 ** with PBCC and CCK modulation. Either both at CCK or both at PBCC.
2572 ** In theory you can implement it, but so far it is considered not worth doing.
2574 ** 22Mbit, of course, is PBCC always. */
2576 /* maps acx100 tx descr rate field to acx111 one */
2578 static u16 rate100to111(u8 r)
2586 case (RATE100_5 | RATE100_PBCC511):
2589 case (RATE100_11 | RATE100_PBCC511):
2594 printk("acx: unexpected acx100 txrate: %u! "
2595 "Please report\n", r);
2603 acx_i_start_xmit(struct ieee80211_hw
*hw
,
2604 struct sk_buff
*skb
, struct ieee80211_tx_control
*ctl
)
2606 acx_device_t
*adev
= ieee2adev(hw
);
2609 unsigned long flags
;
2611 int txresult
= NOT_OK
;
2615 acx_lock(adev
, flags
);
2617 if (unlikely(!skb
)) {
2618 /* indicate success */
2623 if (unlikely(!adev
)) {
2628 if (unlikely(!(adev
->dev_state_mask
& ACX_STATE_IFACE_UP
))) {
2631 if (unlikely(!adev
->initialized
)) {
2635 acx_unlock(adev
, flags
);
2636 tx
= acx_l_alloc_tx(adev
);
2637 acx_lock(adev
, flags
);
2639 if (unlikely(!tx
)) {
2640 printk_ratelimited("%s: start_xmit: txdesc ring is full, "
2641 "dropping tx\n", wiphy_name(adev
->ieee
->wiphy
));
2646 acx_unlock(adev
, flags
);
2648 txbuf
= acx_l_get_txbuf(adev
, tx
);
2650 acx_lock(adev
, flags
);
2652 if (unlikely(!txbuf
)) {
2653 /* Card was removed */
2655 acx_l_dealloc_tx(adev
, tx
);
2658 memcpy(txbuf
, skb
->data
, skb
->len
);
2660 acx_unlock(adev
, flags
);
2662 acx_l_tx_data(adev
, tx
, skb
->len
, ctl
,skb
);
2665 adev
->stats
.tx_packets
++;
2666 adev
->stats
.tx_bytes
+= skb
->len
;
2668 acx_lock(adev
, flags
);
2671 acx_unlock(adev
, flags
);
2676 /***********************************************************************
2677 ** acx_l_update_ratevector
2679 ** Updates adev->rate_supported[_len] according to rate_{basic,oper}
2681 const u8 acx_bitpos2ratebyte
[] = {
2697 void acx_l_update_ratevector(acx_device_t
* adev
)
2699 u16 bcfg
= adev
->rate_basic
;
2700 u16 ocfg
= adev
->rate_oper
;
2701 u8
*supp
= adev
->rate_supported
;
2702 const u8
*dot11
= acx_bitpos2ratebyte
;
2718 adev
->rate_supported_len
= supp
- adev
->rate_supported
;
2719 if (acx_debug
& L_ASSOC
) {
2720 printk("new ratevector: ");
2721 acx_dump_bytes(adev
->rate_supported
, adev
->rate_supported_len
);
2726 /***********************************************************************
2729 ** Fires up periodically. Used to kick scan/auth/assoc if something goes wrong
2733 void acx_i_timer(unsigned long address
)
2735 unsigned long flags
;
2736 acx_device_t
*adev
= (acx_device_t
*) address
;
2740 acx_lock(adev
, flags
);
2743 /* We need calibration and stats gather tasks to perform here */
2745 acx_unlock(adev
, flags
);
2751 /***********************************************************************
2754 ** Sets the 802.11 state management timer's timeout.
2758 void acx_set_timer(acx_device_t
* adev
, int timeout_us
)
2762 log(L_DEBUG
| L_IRQ
, "%s(%u ms)\n", __func__
, timeout_us
/ 1000);
2763 if (!(adev
->dev_state_mask
& ACX_STATE_IFACE_UP
)) {
2764 printk("attempt to set the timer "
2765 "when the card interface is not up!\n");
2769 /* first check if the timer was already initialized, THEN modify it */
2770 if (adev
->mgmt_timer
.function
) {
2771 mod_timer(&adev
->mgmt_timer
,
2772 jiffies
+ (timeout_us
* HZ
/ 1000000));
2778 /** acx_plcp_get_bitrate_cck
2782 static u8
acx_plcp_get_bitrate_cck(u8 plcp
)
2786 return ACX_CCK_RATE_1MB
;
2788 return ACX_CCK_RATE_2MB
;
2790 return ACX_CCK_RATE_5MB
;
2792 return ACX_CCK_RATE_11MB
;
2797 /* Extract the bitrate out of an OFDM PLCP header. */
2799 static u8
acx_plcp_get_bitrate_ofdm(u8 plcp
)
2801 switch (plcp
& 0xF) {
2803 return ACX_OFDM_RATE_6MB
;
2805 return ACX_OFDM_RATE_9MB
;
2807 return ACX_OFDM_RATE_12MB
;
2809 return ACX_OFDM_RATE_18MB
;
2811 return ACX_OFDM_RATE_24MB
;
2813 return ACX_OFDM_RATE_36MB
;
2815 return ACX_OFDM_RATE_48MB
;
2817 return ACX_OFDM_RATE_54MB
;
2823 /***********************************************************************
2826 ** The end of the Rx path. Pulls data from a rxhostdesc into a socket
2827 ** buffer and feeds it to the network stack via netif_rx().
2829 ** Look to bcm43xx or p54
2831 static void acx_l_rx(acx_device_t
* adev
, rxbuffer_t
* rxbuf
)
2834 struct ieee80211_rx_status
* status
= &adev
->rx_status
;
2835 struct ieee80211_hdr
*w_hdr
;
2839 if (likely(adev
->dev_state_mask
& ACX_STATE_IFACE_UP
)) {
2840 struct sk_buff
*skb
;
2841 w_hdr
= acx_get_wlan_hdr(adev
, rxbuf
);
2842 buflen
= RXBUF_BYTES_USED(rxbuf
) - ((u8
*)w_hdr
- (u8
*)rxbuf
);
2843 skb
= dev_alloc_skb(buflen
+ 2);
2844 skb_reserve(skb
, 2);
2845 skb_put(skb
, buflen
);
2846 memcpy(skb
->data
, w_hdr
, buflen
);
2848 // memset(&status, 0, sizeof(status));
2851 status
->mactime
= rxbuf
->time
;
2852 status
->signal
= acx_signal_to_winlevel(rxbuf
->phy_level
);
2853 status
->noise
= acx_signal_to_winlevel(rxbuf
->phy_snr
);
2855 status
->rate
= rxbuf
->phy_plcp_signal
;
2856 status
->antenna
= 1;
2859 qual = acx_signal_determine_quality(adev->wstats.qual.level,
2860 adev->wstats.qual.noise);
2862 qual = (adev->wstats.qual.noise <= 100) ?
2863 100 - adev->wstats.qual.noise : 0;
2865 adev->wstats.qual.qual = qual;
2866 adev->wstats.qual.updated = 7; *//* all 3 indicators updated */
2868 #ifdef FROM_SCAN_SOURCE_ONLY
2872 if (rxbuf
->phy_stat_baseband
& (1 << 3)) /* Uses OFDM */
2874 status
->rate
= acx_plcp_get_bitrate_ofdm(rxbuf
->phy_plcp_signal
);
2877 status
->rate
= acx_plcp_get_bitrate_cck(rxbuf
->phy_plcp_signal
);
2879 ieee80211_rx_irqsafe(adev
->ieee
, skb
, status
);
2880 adev
->stats
.rx_packets
++;
2881 adev
->stats
.rx_bytes
+= skb
->len
;
2889 /***********************************************************************
2892 ** Loads a firmware image
2895 ** 0 unable to load file
2896 ** pointer to firmware success
2898 firmware_image_t
*acx_s_read_fw(struct device
*dev
, const char *file
,
2901 firmware_image_t
*res
;
2902 const struct firmware
*fw_entry
;
2905 log(L_INIT
, "requesting firmware image '%s'\n", file
);
2906 if (!request_firmware(&fw_entry
, file
, dev
)) {
2908 if (fw_entry
->size
>= 8)
2909 *size
= 8 + le32_to_cpu(*(u32
*) (fw_entry
->data
+ 4));
2910 if (fw_entry
->size
!= *size
) {
2911 printk("acx: firmware size does not match "
2912 "firmware header: %d != %d, "
2913 "aborting fw upload\n",
2914 (int)fw_entry
->size
, (int)*size
);
2917 res
= vmalloc(*size
);
2919 printk("acx: no memory for firmware "
2920 "(%u bytes)\n", *size
);
2923 memcpy(res
, fw_entry
->data
, fw_entry
->size
);
2925 release_firmware(fw_entry
);
2928 printk("acx: firmware image '%s' was not provided. "
2929 "Check your hotplug scripts\n", file
);
2931 /* checksum will be verified in write_fw, so don't bother here */
2936 /***********************************************************************
2939 static void acx100_s_set_wepkey(acx_device_t
* adev
)
2941 ie_dot11WEPDefaultKey_t dk
;
2944 for (i
= 0; i
< DOT11_MAX_DEFAULT_WEP_KEYS
; i
++) {
2945 if (adev
->wep_keys
[i
].size
!= 0) {
2946 log(L_INIT
, "setting WEP key: %d with "
2947 "total size: %d\n", i
, (int)adev
->wep_keys
[i
].size
);
2949 dk
.keySize
= adev
->wep_keys
[i
].size
;
2950 dk
.defaultKeyNum
= i
;
2951 memcpy(dk
.key
, adev
->wep_keys
[i
].key
, dk
.keySize
);
2952 acx_s_configure(adev
, &dk
,
2953 ACX100_IE_DOT11_WEP_DEFAULT_KEY_WRITE
);
2958 static void acx111_s_set_wepkey(acx_device_t
* adev
)
2960 acx111WEPDefaultKey_t dk
;
2963 for (i
= 0; i
< DOT11_MAX_DEFAULT_WEP_KEYS
; i
++) {
2964 if (adev
->wep_keys
[i
].size
!= 0) {
2965 log(L_INIT
, "setting WEP key: %d with "
2966 "total size: %d\n", i
, (int)adev
->wep_keys
[i
].size
);
2967 memset(&dk
, 0, sizeof(dk
));
2968 dk
.action
= cpu_to_le16(1); /* "add key"; yes, that's a 16bit value */
2969 dk
.keySize
= adev
->wep_keys
[i
].size
;
2971 /* are these two lines necessary? */
2972 dk
.type
= 0; /* default WEP key */
2973 dk
.index
= 0; /* ignored when setting default key */
2975 dk
.defaultKeyNum
= i
;
2976 memcpy(dk
.key
, adev
->wep_keys
[i
].key
, dk
.keySize
);
2977 acx_s_issue_cmd(adev
, ACX1xx_CMD_WEP_MGMT
, &dk
,
2983 static void acx_s_set_wepkey(acx_device_t
* adev
)
2985 if (IS_ACX111(adev
))
2986 acx111_s_set_wepkey(adev
);
2988 acx100_s_set_wepkey(adev
);
2992 /***********************************************************************
2993 ** acx100_s_init_wep
2995 ** FIXME: this should probably be moved into the new card settings
2996 ** management, but since we're also modifying the memory map layout here
2997 ** due to the WEP key space we want, we should take care...
2999 static int acx100_s_init_wep(acx_device_t
* adev
)
3001 acx100_ie_wep_options_t options
;
3002 ie_dot11WEPDefaultKeyID_t dk
;
3008 if (OK
!= acx_s_interrogate(adev
, &pt
, ACX1xx_IE_MEMORY_MAP
)) {
3012 log(L_DEBUG
, "CodeEnd:%X\n", pt
.CodeEnd
);
3014 pt
.WEPCacheStart
= cpu_to_le32(le32_to_cpu(pt
.CodeEnd
) + 0x4);
3015 pt
.WEPCacheEnd
= cpu_to_le32(le32_to_cpu(pt
.CodeEnd
) + 0x4);
3017 if (OK
!= acx_s_configure(adev
, &pt
, ACX1xx_IE_MEMORY_MAP
)) {
3021 /* let's choose maximum setting: 4 default keys, plus 10 other keys: */
3022 options
.NumKeys
= cpu_to_le16(DOT11_MAX_DEFAULT_WEP_KEYS
+ 10);
3023 options
.WEPOption
= 0x00;
3025 log(L_ASSOC
, "writing WEP options\n");
3026 acx_s_configure(adev
, &options
, ACX100_IE_WEP_OPTIONS
);
3028 acx100_s_set_wepkey(adev
);
3030 if (adev
->wep_keys
[adev
->wep_current_index
].size
!= 0) {
3031 log(L_ASSOC
, "setting active default WEP key number: %d\n",
3032 adev
->wep_current_index
);
3033 dk
.KeyID
= adev
->wep_current_index
;
3034 acx_s_configure(adev
, &dk
, ACX1xx_IE_DOT11_WEP_DEFAULT_KEY_SET
); /* 0x1010 */
3036 /* FIXME!!! wep_key_struct is filled nowhere! But adev
3037 * is initialized to 0, and we don't REALLY need those keys either */
3038 /* for (i = 0; i < 10; i++) {
3039 if (adev->wep_key_struct[i].len != 0) {
3040 MAC_COPY(wep_mgmt.MacAddr, adev->wep_key_struct[i].addr);
3041 wep_mgmt.KeySize = cpu_to_le16(adev->wep_key_struct[i].len);
3042 memcpy(&wep_mgmt.Key, adev->wep_key_struct[i].key, le16_to_cpu(wep_mgmt.KeySize));
3043 wep_mgmt.Action = cpu_to_le16(1);
3044 log(L_ASSOC, "writing WEP key %d (len %d)\n", i, le16_to_cpu(wep_mgmt.KeySize));
3045 if (OK == acx_s_issue_cmd(adev, ACX1xx_CMD_WEP_MGMT, &wep_mgmt, sizeof(wep_mgmt))) {
3046 adev->wep_key_struct[i].index = i;
3052 /* now retrieve the updated WEPCacheEnd pointer... */
3053 if (OK
!= acx_s_interrogate(adev
, &pt
, ACX1xx_IE_MEMORY_MAP
)) {
3054 printk("%s: ACX1xx_IE_MEMORY_MAP read #2 FAILED\n",
3055 wiphy_name(adev
->ieee
->wiphy
));
3058 /* ...and tell it to start allocating templates at that location */
3059 /* (no endianness conversion needed) */
3060 pt
.PacketTemplateStart
= pt
.WEPCacheEnd
;
3062 if (OK
!= acx_s_configure(adev
, &pt
, ACX1xx_IE_MEMORY_MAP
)) {
3063 printk("%s: ACX1xx_IE_MEMORY_MAP write #2 FAILED\n",
3064 wiphy_name(adev
->ieee
->wiphy
));
3076 acx_s_init_max_template_generic(acx_device_t
* adev
, unsigned int len
,
3081 acx_template_nullframe_t null
;
3082 acx_template_beacon_t b
;
3083 acx_template_tim_t tim
;
3084 acx_template_probereq_t preq
;
3085 acx_template_proberesp_t presp
;
3088 memset(&templ
, 0, len
);
3089 templ
.null
.size
= cpu_to_le16(len
- 2);
3090 res
= acx_s_issue_cmd(adev
, cmd
, &templ
, len
);
3094 static inline int acx_s_init_max_null_data_template(acx_device_t
* adev
)
3096 return acx_s_init_max_template_generic(adev
,
3097 sizeof(acx_template_nullframe_t
),
3098 ACX1xx_CMD_CONFIG_NULL_DATA
);
3101 static inline int acx_s_init_max_beacon_template(acx_device_t
* adev
)
3103 return acx_s_init_max_template_generic(adev
,
3104 sizeof(acx_template_beacon_t
),
3105 ACX1xx_CMD_CONFIG_BEACON
);
3108 static inline int acx_s_init_max_tim_template(acx_device_t
* adev
)
3110 return acx_s_init_max_template_generic(adev
, sizeof(acx_template_tim_t
),
3111 ACX1xx_CMD_CONFIG_TIM
);
3114 static inline int acx_s_init_max_probe_response_template(acx_device_t
* adev
)
3116 return acx_s_init_max_template_generic(adev
,
3117 sizeof(acx_template_proberesp_t
),
3118 ACX1xx_CMD_CONFIG_PROBE_RESPONSE
);
3121 static inline int acx_s_init_max_probe_request_template(acx_device_t
* adev
)
3123 return acx_s_init_max_template_generic(adev
,
3124 sizeof(acx_template_probereq_t
),
3125 ACX1xx_CMD_CONFIG_PROBE_REQUEST
);
3128 /***********************************************************************
3129 ** acx_s_set_tim_template
3131 ** FIXME: In full blown driver we will regularly update partial virtual bitmap
3132 ** by calling this function
3133 ** (it can be done by irq handler on each DTIM irq or by timer...)
3135 [802.11 7.3.2.6] TIM information element:
3139 indicates how many beacons (including this) appear before next DTIM
3140 (0=this one is a DTIM)
3142 number of beacons between successive DTIMs
3143 (0=reserved, 1=all TIMs are DTIMs, 2=every other, etc)
3145 bit0: Traffic Indicator bit associated with Assoc ID 0 (Bcast AID?)
3146 set to 1 in TIM elements with a value of 0 in the DTIM Count field
3147 when one or more broadcast or multicast frames are buffered at the AP.
3148 bit1-7: Bitmap Offset (logically Bitmap_Offset = Bitmap_Control & 0xFE).
3149 4 n Partial Virtual Bitmap
3150 Visible part of traffic-indication bitmap.
3151 Full bitmap consists of 2008 bits (251 octets) such that bit number N
3152 (0<=N<=2007) in the bitmap corresponds to bit number (N mod 8)
3153 in octet number N/8 where the low-order bit of each octet is bit0,
3154 and the high order bit is bit7.
3155 Each set bit in virtual bitmap corresponds to traffic buffered by AP
3156 for a specific station (with corresponding AID?).
3157 Partial Virtual Bitmap shows a part of bitmap which has non-zero.
3158 Bitmap Offset is a number of skipped zero octets (see above).
3159 'Missing' octets at the tail are also assumed to be zero.
3160 Example: Length=6, Bitmap_Offset=2, Partial_Virtual_Bitmap=55 55 55
3161 This means that traffic-indication bitmap is:
3162 00000000 00000000 01010101 01010101 01010101 00000000 00000000...
3163 (is bit0 in the map is always 0 and real value is in Bitmap Control bit0?)
3165 static int acx_s_set_tim_template(acx_device_t
* adev
)
3167 /* For now, configure smallish test bitmap, all zero ("no pending data") */
3168 enum { bitmap_size
= 5 };
3170 acx_template_tim_t t
;
3175 memset(&t
, 0, sizeof(t
));
3176 t
.size
= 5 + bitmap_size
; /* eid+len+count+period+bmap_ctrl + bmap */
3177 t
.tim_eid
= WLAN_EID_TIM
;
3178 t
.len
= 3 + bitmap_size
; /* count+period+bmap_ctrl + bmap */
3179 result
= acx_s_issue_cmd(adev
, ACX1xx_CMD_CONFIG_TIM
, &t
, sizeof(t
));
3187 #if POWER_SAVE_80211
3188 /***********************************************************************
3189 ** acx_s_set_null_data_template
3191 static int acx_s_set_null_data_template(acx_device_t
* adev
)
3193 struct acx_template_nullframe b
;
3198 /* memset(&b, 0, sizeof(b)); not needed, setting all members */
3200 b
.size
= cpu_to_le16(sizeof(b
) - 2);
3201 b
.hdr
.fc
= WF_FTYPE_MGMTi
| WF_FSTYPE_NULLi
;
3203 MAC_BCAST(b
.hdr
.a1
);
3204 MAC_COPY(b
.hdr
.a2
, adev
->dev_addr
);
3205 MAC_COPY(b
.hdr
.a3
, adev
->bssid
);
3209 acx_s_issue_cmd(adev
, ACX1xx_CMD_CONFIG_NULL_DATA
, &b
, sizeof(b
));
3221 /***********************************************************************
3222 ** acx_s_init_packet_templates()
3224 ** NOTE: order is very important here, to have a correct memory layout!
3225 ** init templates: max Probe Request (station mode), max NULL data,
3226 ** max Beacon, max TIM, max Probe Response.
3228 static int acx_s_init_packet_templates(acx_device_t
* adev
)
3230 acx_ie_memmap_t mm
; /* ACX100 only */
3231 int result
= NOT_OK
;
3235 log(L_DEBUG
| L_INIT
, "initializing max packet templates\n");
3237 if (OK
!= acx_s_init_max_probe_request_template(adev
))
3240 if (OK
!= acx_s_init_max_null_data_template(adev
))
3243 if (OK
!= acx_s_init_max_beacon_template(adev
))
3246 if (OK
!= acx_s_init_max_tim_template(adev
))
3249 if (OK
!= acx_s_init_max_probe_response_template(adev
))
3252 if (IS_ACX111(adev
)) {
3253 /* ACX111 doesn't need the memory map magic below,
3254 * and the other templates will be set later (acx_start) */
3259 /* ACX100 will have its TIM template set,
3260 * and we also need to update the memory map */
3262 if (OK
!= acx_s_set_tim_template(adev
))
3265 log(L_DEBUG
, "sizeof(memmap)=%d bytes\n", (int)sizeof(mm
));
3267 if (OK
!= acx_s_interrogate(adev
, &mm
, ACX1xx_IE_MEMORY_MAP
))
3270 mm
.QueueStart
= cpu_to_le32(le32_to_cpu(mm
.PacketTemplateEnd
) + 4);
3271 if (OK
!= acx_s_configure(adev
, &mm
, ACX1xx_IE_MEMORY_MAP
))
3278 log(L_DEBUG
| L_INIT
,
3283 ".WEPCacheStart=0x%X\n"
3284 ".WEPCacheEnd=0x%X\n"
3285 ".PacketTemplateStart=0x%X\n" ".PacketTemplateEnd=0x%X\n",
3287 le32_to_cpu(mm
.CodeStart
),
3288 le32_to_cpu(mm
.CodeEnd
),
3289 le32_to_cpu(mm
.WEPCacheStart
),
3290 le32_to_cpu(mm
.WEPCacheEnd
),
3291 le32_to_cpu(mm
.PacketTemplateStart
),
3292 le32_to_cpu(mm
.PacketTemplateEnd
));
3295 printk("%s: %s() FAILED\n", wiphy_name(adev
->ieee
->wiphy
), __func__
);
3304 /***********************************************************************
3307 int acx_s_init_mac(acx_device_t
* adev
)
3309 int result
= NOT_OK
;
3313 if (IS_ACX111(adev
)) {
3314 adev
->ie_len
= acx111_ie_len
;
3315 adev
->ie_len_dot11
= acx111_ie_len_dot11
;
3317 adev
->ie_len
= acx100_ie_len
;
3318 adev
->ie_len_dot11
= acx100_ie_len_dot11
;
3322 adev
->memblocksize
= 256; /* 256 is default */
3323 /* try to load radio for both ACX100 and ACX111, since both
3324 * chips have at least some firmware versions making use of an
3325 * external radio module */
3326 acxpci_s_upload_radio(adev
);
3328 adev
->memblocksize
= 128;
3331 if (IS_ACX111(adev
)) {
3332 /* for ACX111, the order is different from ACX100
3333 1. init packet templates
3334 2. create station context and create dma regions
3335 3. init wep default keys
3337 if (OK
!= acx_s_init_packet_templates(adev
))
3339 if (OK
!= acx111_s_create_dma_regions(adev
)) {
3340 printk("%s: acx111_create_dma_regions FAILED\n",
3341 wiphy_name(adev
->ieee
->wiphy
));
3345 if (OK
!= acx100_s_init_wep(adev
))
3347 if (OK
!= acx_s_init_packet_templates(adev
))
3349 if (OK
!= acx100_s_create_dma_regions(adev
)) {
3350 printk("%s: acx100_create_dma_regions FAILED\n",
3351 wiphy_name(adev
->ieee
->wiphy
));
3356 SET_IEEE80211_PERM_ADDR(adev
->ieee
, adev
->dev_addr
);
3361 printk("acx: init_mac() FAILED\n");
3368 #if POWER_SAVE_80211
3369 static void acx_s_update_80211_powersave_mode(acx_device_t
* adev
)
3371 /* merge both structs in a union to be able to have common code */
3373 acx111_ie_powersave_t acx111
;
3374 acx100_ie_powersave_t acx100
;
3377 /* change 802.11 power save mode settings */
3378 log(L_INIT
, "updating 802.11 power save mode settings: "
3379 "wakeup_cfg 0x%02X, listen interval %u, "
3380 "options 0x%02X, hangover period %u, "
3381 "enhanced_ps_transition_time %u\n",
3382 adev
->ps_wakeup_cfg
, adev
->ps_listen_interval
,
3383 adev
->ps_options
, adev
->ps_hangover_period
,
3384 adev
->ps_enhanced_transition_time
);
3385 acx_s_interrogate(adev
, &pm
, ACX1xx_IE_POWER_MGMT
);
3386 log(L_INIT
, "Previous PS mode settings: wakeup_cfg 0x%02X, "
3387 "listen interval %u, options 0x%02X, "
3388 "hangover period %u, "
3389 "enhanced_ps_transition_time %u, beacon_rx_time %u\n",
3390 pm
.acx111
.wakeup_cfg
,
3391 pm
.acx111
.listen_interval
,
3393 pm
.acx111
.hangover_period
,
3395 pm
.acx111
.enhanced_ps_transition_time
3396 : pm
.acx100
.enhanced_ps_transition_time
,
3397 IS_ACX111(adev
) ? pm
.acx111
.beacon_rx_time
: (u32
) - 1);
3398 pm
.acx111
.wakeup_cfg
= adev
->ps_wakeup_cfg
;
3399 pm
.acx111
.listen_interval
= adev
->ps_listen_interval
;
3400 pm
.acx111
.options
= adev
->ps_options
;
3401 pm
.acx111
.hangover_period
= adev
->ps_hangover_period
;
3402 if (IS_ACX111(adev
)) {
3403 pm
.acx111
.beacon_rx_time
= cpu_to_le32(adev
->ps_beacon_rx_time
);
3404 pm
.acx111
.enhanced_ps_transition_time
=
3405 cpu_to_le32(adev
->ps_enhanced_transition_time
);
3407 pm
.acx100
.enhanced_ps_transition_time
=
3408 cpu_to_le16(adev
->ps_enhanced_transition_time
);
3410 acx_s_configure(adev
, &pm
, ACX1xx_IE_POWER_MGMT
);
3411 acx_s_interrogate(adev
, &pm
, ACX1xx_IE_POWER_MGMT
);
3412 log(L_INIT
, "wakeup_cfg: 0x%02X\n", pm
.acx111
.wakeup_cfg
);
3414 acx_s_interrogate(adev
, &pm
, ACX1xx_IE_POWER_MGMT
);
3415 log(L_INIT
, "wakeup_cfg: 0x%02X\n", pm
.acx111
.wakeup_cfg
);
3416 log(L_INIT
, "power save mode change %s\n",
3418 wakeup_cfg
& PS_CFG_PENDING
) ? "FAILED" : "was successful");
3419 /* FIXME: maybe verify via PS_CFG_PENDING bit here
3420 * that power save mode change was successful. */
3421 /* FIXME: we shouldn't trigger a scan immediately after
3422 * fiddling with power save mode (since the firmware is sending
3423 * a NULL frame then). */
3428 /***********************************************************************
3429 ** acx_s_update_card_settings
3431 ** Applies accumulated changes in various adev->xxxx members
3432 ** Called by ioctl commit handler, acx_start, acx_set_defaults,
3433 ** acx_s_after_interrupt_task (if IRQ_CMD_UPDATE_CARD_CFG),
3435 void acx_s_set_sane_reg_domain(acx_device_t
*adev
, int do_set
)
3441 for (i
= 0; i
< sizeof(acx_reg_domain_ids
); i
++)
3442 if (acx_reg_domain_ids
[i
] == adev
->reg_dom_id
)
3445 if (sizeof(acx_reg_domain_ids
) == i
) {
3446 log(L_INIT
, "Invalid or unsupported regulatory domain"
3447 " 0x%02X specified, falling back to FCC (USA)!"
3448 " Please report if this sounds fishy!\n",
3451 adev
->reg_dom_id
= acx_reg_domain_ids
[i
];
3453 /* since there was a mismatch, we need to force updating */
3458 acx_ie_generic_t dom
;
3459 dom
.m
.bytes
[0] = adev
->reg_dom_id
;
3460 acx_s_configure(adev
, &dom
, ACX1xx_IE_DOT11_CURRENT_REG_DOMAIN
);
3463 adev
->reg_dom_chanmask
= reg_domain_channel_masks
[i
];
3465 mask
= (1 << (adev
->channel
- 1));
3466 if (!(adev
->reg_dom_chanmask
& mask
)) {
3467 /* hmm, need to adjust our channel to reside within domain */
3469 for (i
= 1; i
<= 14; i
++) {
3470 if (adev
->reg_dom_chanmask
& mask
) {
3471 printk("%s: adjusting selected channel from %d "
3472 "to %d due to new regulatory domain\n",
3473 wiphy_name(adev
->ieee
->wiphy
), adev
->channel
, i
);
3482 static void acx111_s_sens_radio_16_17(acx_device_t
* adev
)
3484 u32 feature1
, feature2
;
3486 if ((adev
->sensitivity
< 1) || (adev
->sensitivity
> 3)) {
3487 printk("%s: invalid sensitivity setting (1..3), "
3488 "setting to 1\n", wiphy_name(adev
->ieee
->wiphy
));
3489 adev
->sensitivity
= 1;
3491 acx111_s_get_feature_config(adev
, &feature1
, &feature2
);
3492 CLEAR_BIT(feature1
, FEATURE1_LOW_RX
| FEATURE1_EXTRA_LOW_RX
);
3493 if (adev
->sensitivity
> 1)
3494 SET_BIT(feature1
, FEATURE1_LOW_RX
);
3495 if (adev
->sensitivity
> 2)
3496 SET_BIT(feature1
, FEATURE1_EXTRA_LOW_RX
);
3497 acx111_s_feature_set(adev
, feature1
, feature2
);
3501 void acx_s_update_card_settings(acx_device_t
*adev
)
3503 unsigned long flags
;
3504 unsigned int start_scan
= 0;
3509 log(L_INIT
, "get_mask 0x%08X, set_mask 0x%08X\n",
3510 adev
->get_mask
, adev
->set_mask
);
3512 /* Track dependencies betweed various settings */
3514 if (adev
->set_mask
& (GETSET_MODE
| GETSET_RESCAN
| GETSET_WEP
)) {
3515 log(L_INIT
, "important setting has been changed. "
3516 "Need to update packet templates, too\n");
3517 SET_BIT(adev
->set_mask
, SET_TEMPLATES
);
3519 if (adev
->set_mask
& GETSET_CHANNEL
) {
3520 /* This will actually tune RX/TX to the channel */
3521 SET_BIT(adev
->set_mask
, GETSET_RX
| GETSET_TX
);
3522 switch (adev
->mode
) {
3523 case ACX_MODE_0_ADHOC
:
3525 /* Beacons contain channel# - update them */
3526 SET_BIT(adev
->set_mask
, SET_TEMPLATES
);
3529 switch (adev
->mode
) {
3530 case ACX_MODE_0_ADHOC
:
3531 case ACX_MODE_2_STA
:
3536 /* Apply settings */
3539 if (adev
->get_mask
& GETSET_STATION_ID
) {
3540 u8 stationID
[4 + ACX1xx_IE_DOT11_STATION_ID_LEN
];
3543 acx_s_interrogate(adev
, &stationID
, ACX1xx_IE_DOT11_STATION_ID
);
3544 paddr
= &stationID
[4];
3545 // memcpy(adev->dev_addr, adev->ndev->dev_addr, ETH_ALEN);
3546 for (i
= 0; i
< ETH_ALEN
; i
++) {
3547 /* we copy the MAC address (reversed in
3548 * the card) to the netdevice's MAC
3549 * address, and on ifup it will be
3550 * copied into iwadev->dev_addr */
3551 adev
->dev_addr
[ETH_ALEN
- 1 - i
] = paddr
[i
];
3553 SET_IEEE80211_PERM_ADDR(adev
->ieee
,adev
->dev_addr
);
3554 CLEAR_BIT(adev
->get_mask
, GETSET_STATION_ID
);
3557 if (adev
->get_mask
& GETSET_SENSITIVITY
) {
3558 if ((RADIO_RFMD_11
== adev
->radio_type
)
3559 || (RADIO_MAXIM_0D
== adev
->radio_type
)
3560 || (RADIO_RALINK_15
== adev
->radio_type
)) {
3561 acx_s_read_phy_reg(adev
, 0x30, &adev
->sensitivity
);
3563 log(L_INIT
, "don't know how to get sensitivity "
3564 "for radio type 0x%02X\n", adev
->radio_type
);
3565 adev
->sensitivity
= 0;
3567 log(L_INIT
, "got sensitivity value %u\n", adev
->sensitivity
);
3569 CLEAR_BIT(adev
->get_mask
, GETSET_SENSITIVITY
);
3572 if (adev
->get_mask
& GETSET_ANTENNA
) {
3573 u8 antenna
[4 + ACX1xx_IE_DOT11_CURRENT_ANTENNA_LEN
];
3575 memset(antenna
, 0, sizeof(antenna
));
3576 acx_s_interrogate(adev
, antenna
,
3577 ACX1xx_IE_DOT11_CURRENT_ANTENNA
);
3578 adev
->antenna
= antenna
[4];
3579 log(L_INIT
, "got antenna value 0x%02X\n", adev
->antenna
);
3580 CLEAR_BIT(adev
->get_mask
, GETSET_ANTENNA
);
3583 if (adev
->get_mask
& GETSET_ED_THRESH
) {
3584 if (IS_ACX100(adev
)) {
3585 u8 ed_threshold
[4 + ACX100_IE_DOT11_ED_THRESHOLD_LEN
];
3587 memset(ed_threshold
, 0, sizeof(ed_threshold
));
3588 acx_s_interrogate(adev
, ed_threshold
,
3589 ACX100_IE_DOT11_ED_THRESHOLD
);
3590 adev
->ed_threshold
= ed_threshold
[4];
3592 log(L_INIT
, "acx111 doesn't support ED\n");
3593 adev
->ed_threshold
= 0;
3595 log(L_INIT
, "got Energy Detect (ED) threshold %u\n",
3596 adev
->ed_threshold
);
3597 CLEAR_BIT(adev
->get_mask
, GETSET_ED_THRESH
);
3600 if (adev
->get_mask
& GETSET_CCA
) {
3601 if (IS_ACX100(adev
)) {
3602 u8 cca
[4 + ACX1xx_IE_DOT11_CURRENT_CCA_MODE_LEN
];
3604 memset(cca
, 0, sizeof(adev
->cca
));
3605 acx_s_interrogate(adev
, cca
,
3606 ACX1xx_IE_DOT11_CURRENT_CCA_MODE
);
3609 log(L_INIT
, "acx111 doesn't support CCA\n");
3612 log(L_INIT
, "got Channel Clear Assessment (CCA) value %u\n",
3614 CLEAR_BIT(adev
->get_mask
, GETSET_CCA
);
3617 if (adev
->get_mask
& GETSET_REG_DOMAIN
) {
3618 acx_ie_generic_t dom
;
3620 acx_s_interrogate(adev
, &dom
,
3621 ACX1xx_IE_DOT11_CURRENT_REG_DOMAIN
);
3622 adev
->reg_dom_id
= dom
.m
.bytes
[0];
3623 acx_s_set_sane_reg_domain(adev
, 0);
3624 log(L_INIT
, "got regulatory domain 0x%02X\n", adev
->reg_dom_id
);
3625 CLEAR_BIT(adev
->get_mask
, GETSET_REG_DOMAIN
);
3628 if (adev
->set_mask
& GETSET_STATION_ID
) {
3629 u8 stationID
[4 + ACX1xx_IE_DOT11_STATION_ID_LEN
];
3632 paddr
= &stationID
[4];
3633 MAC_COPY(adev
->dev_addr
, adev
->ieee
->wiphy
->perm_addr
);
3634 for (i
= 0; i
< ETH_ALEN
; i
++) {
3635 /* copy the MAC address we obtained when we noticed
3636 * that the ethernet iface's MAC changed
3637 * to the card (reversed in
3639 paddr
[i
] = adev
->dev_addr
[ETH_ALEN
- 1 - i
];
3641 acx_s_configure(adev
, &stationID
, ACX1xx_IE_DOT11_STATION_ID
);
3642 CLEAR_BIT(adev
->set_mask
, GETSET_STATION_ID
);
3645 if (adev
->set_mask
& SET_STA_LIST
) {
3646 acx_lock(adev
, flags
);
3647 CLEAR_BIT(adev
->set_mask
, SET_STA_LIST
);
3648 acx_unlock(adev
, flags
);
3650 if (adev
->set_mask
& SET_RATE_FALLBACK
) {
3651 u8 rate
[4 + ACX1xx_IE_RATE_FALLBACK_LEN
];
3653 /* configure to not do fallbacks when not in auto rate mode */
3656 rate_auto
) ? /* adev->txrate_fallback_retries */ 1 : 0;
3657 log(L_INIT
, "updating Tx fallback to %u retries\n", rate
[4]);
3658 acx_s_configure(adev
, &rate
, ACX1xx_IE_RATE_FALLBACK
);
3659 CLEAR_BIT(adev
->set_mask
, SET_RATE_FALLBACK
);
3661 if (adev
->set_mask
& GETSET_TXPOWER
) {
3662 log(L_INIT
, "updating transmit power: %u dBm\n",
3663 adev
->tx_level_dbm
);
3664 acx_s_set_tx_level(adev
, adev
->tx_level_dbm
);
3665 CLEAR_BIT(adev
->set_mask
, GETSET_TXPOWER
);
3668 if (adev
->set_mask
& GETSET_SENSITIVITY
) {
3669 log(L_INIT
, "updating sensitivity value: %u\n",
3671 switch (adev
->radio_type
) {
3673 case RADIO_MAXIM_0D
:
3674 case RADIO_RALINK_15
:
3675 acx_s_write_phy_reg(adev
, 0x30, adev
->sensitivity
);
3677 case RADIO_RADIA_16
:
3678 case RADIO_UNKNOWN_17
:
3679 acx111_s_sens_radio_16_17(adev
);
3682 log(L_INIT
, "don't know how to modify sensitivity "
3683 "for radio type 0x%02X\n", adev
->radio_type
);
3685 CLEAR_BIT(adev
->set_mask
, GETSET_SENSITIVITY
);
3688 if (adev
->set_mask
& GETSET_ANTENNA
) {
3690 u8 antenna
[4 + ACX1xx_IE_DOT11_CURRENT_ANTENNA_LEN
];
3692 memset(antenna
, 0, sizeof(antenna
));
3693 antenna
[4] = adev
->antenna
;
3694 log(L_INIT
, "updating antenna value: 0x%02X\n", adev
->antenna
);
3695 acx_s_configure(adev
, &antenna
,
3696 ACX1xx_IE_DOT11_CURRENT_ANTENNA
);
3697 CLEAR_BIT(adev
->set_mask
, GETSET_ANTENNA
);
3700 if (adev
->set_mask
& GETSET_ED_THRESH
) {
3702 log(L_INIT
, "updating Energy Detect (ED) threshold: %u\n",
3703 adev
->ed_threshold
);
3704 if (IS_ACX100(adev
)) {
3705 u8 ed_threshold
[4 + ACX100_IE_DOT11_ED_THRESHOLD_LEN
];
3707 memset(ed_threshold
, 0, sizeof(ed_threshold
));
3708 ed_threshold
[4] = adev
->ed_threshold
;
3709 acx_s_configure(adev
, &ed_threshold
,
3710 ACX100_IE_DOT11_ED_THRESHOLD
);
3712 log(L_INIT
, "acx111 doesn't support ED!\n");
3713 CLEAR_BIT(adev
->set_mask
, GETSET_ED_THRESH
);
3716 if (adev
->set_mask
& GETSET_CCA
) {
3718 log(L_INIT
, "updating Channel Clear Assessment "
3719 "(CCA) value: 0x%02X\n", adev
->cca
);
3720 if (IS_ACX100(adev
)) {
3721 u8 cca
[4 + ACX1xx_IE_DOT11_CURRENT_CCA_MODE_LEN
];
3723 memset(cca
, 0, sizeof(cca
));
3725 acx_s_configure(adev
, &cca
,
3726 ACX1xx_IE_DOT11_CURRENT_CCA_MODE
);
3728 log(L_INIT
, "acx111 doesn't support CCA!\n");
3729 CLEAR_BIT(adev
->set_mask
, GETSET_CCA
);
3732 if (adev
->set_mask
& GETSET_LED_POWER
) {
3734 log(L_INIT
, "updating power LED status: %u\n", adev
->led_power
);
3736 acx_lock(adev
, flags
);
3738 acxpci_l_power_led(adev
, adev
->led_power
);
3739 CLEAR_BIT(adev
->set_mask
, GETSET_LED_POWER
);
3740 acx_unlock(adev
, flags
);
3743 if (adev
->set_mask
& GETSET_POWER_80211
) {
3744 #if POWER_SAVE_80211
3745 acx_s_update_80211_powersave_mode(adev
);
3747 CLEAR_BIT(adev
->set_mask
, GETSET_POWER_80211
);
3750 if (adev
->set_mask
& GETSET_CHANNEL
) {
3752 log(L_INIT
, "updating channel to: %u\n", adev
->channel
);
3753 CLEAR_BIT(adev
->set_mask
, GETSET_CHANNEL
);
3756 if (adev
->set_mask
& GETSET_TX
) {
3758 log(L_INIT
, "updating: %s Tx\n",
3759 adev
->tx_disabled
? "disable" : "enable");
3760 if (adev
->tx_disabled
)
3761 acx_s_issue_cmd(adev
, ACX1xx_CMD_DISABLE_TX
, NULL
, 0);
3763 acx_s_issue_cmd(adev
, ACX1xx_CMD_ENABLE_TX
,
3766 /* This needs to be keyed on WEP? */
3767 /* acx111_s_feature_on(adev, 0,
3768 FEATURE2_NO_TXCRYPT |
3769 FEATURE2_SNIFFER); */
3770 acx_wake_queue(adev
->ieee
, NULL
);
3772 CLEAR_BIT(adev
->set_mask
, GETSET_TX
);
3775 if (adev
->set_mask
& GETSET_RX
) {
3777 log(L_INIT
, "updating: enable Rx on channel: %u\n",
3779 acx_s_issue_cmd(adev
, ACX1xx_CMD_ENABLE_RX
, &adev
->channel
, 1);
3780 CLEAR_BIT(adev
->set_mask
, GETSET_RX
);
3783 if (adev
->set_mask
& GETSET_RETRY
) {
3784 u8 short_retry
[4 + ACX1xx_IE_DOT11_SHORT_RETRY_LIMIT_LEN
];
3785 u8 long_retry
[4 + ACX1xx_IE_DOT11_LONG_RETRY_LIMIT_LEN
];
3788 "updating short retry limit: %u, long retry limit: %u\n",
3789 adev
->short_retry
, adev
->long_retry
);
3790 short_retry
[0x4] = adev
->short_retry
;
3791 long_retry
[0x4] = adev
->long_retry
;
3792 acx_s_configure(adev
, &short_retry
,
3793 ACX1xx_IE_DOT11_SHORT_RETRY_LIMIT
);
3794 acx_s_configure(adev
, &long_retry
,
3795 ACX1xx_IE_DOT11_LONG_RETRY_LIMIT
);
3796 CLEAR_BIT(adev
->set_mask
, GETSET_RETRY
);
3799 if (adev
->set_mask
& SET_MSDU_LIFETIME
) {
3800 u8 xmt_msdu_lifetime
[4 +
3801 ACX1xx_IE_DOT11_MAX_XMIT_MSDU_LIFETIME_LEN
];
3803 log(L_INIT
, "updating tx MSDU lifetime: %u\n",
3804 adev
->msdu_lifetime
);
3805 *(u32
*) & xmt_msdu_lifetime
[4] =
3806 cpu_to_le32((u32
) adev
->msdu_lifetime
);
3807 acx_s_configure(adev
, &xmt_msdu_lifetime
,
3808 ACX1xx_IE_DOT11_MAX_XMIT_MSDU_LIFETIME
);
3809 CLEAR_BIT(adev
->set_mask
, SET_MSDU_LIFETIME
);
3812 if (adev
->set_mask
& GETSET_REG_DOMAIN
) {
3813 log(L_INIT
, "updating regulatory domain: 0x%02X\n",
3815 acx_s_set_sane_reg_domain(adev
, 1);
3816 CLEAR_BIT(adev
->set_mask
, GETSET_REG_DOMAIN
);
3818 if (adev
->set_mask
& GETSET_MODE
) {
3819 acx111_s_feature_on(adev
, 0,
3820 FEATURE2_NO_TXCRYPT
| FEATURE2_SNIFFER
);
3821 switch (adev
->mode
) {
3824 //acx111_s_feature_off(adev, 0,
3825 // FEATURE2_NO_TXCRYPT | FEATURE2_SNIFFER);
3826 MAC_COPY(adev
->bssid
,adev
->dev_addr
);
3827 acx_s_cmd_join_bssid(adev
,adev
->dev_addr
);
3829 case ACX_MODE_MONITOR
:
3830 SET_BIT(adev
->set_mask
, SET_RXCONFIG
| SET_WEP_OPTIONS
);
3832 case ACX_MODE_0_ADHOC
:
3833 case ACX_MODE_2_STA
:
3834 acx111_s_feature_on(adev
, 0, FEATURE2_NO_TXCRYPT
| FEATURE2_SNIFFER
);
3839 CLEAR_BIT(adev
->set_mask
, GETSET_MODE
);
3841 if (adev
->set_mask
& SET_TEMPLATES
) {
3845 acx_s_set_tim_template(adev
);
3850 if (adev
->beacon_cache
)
3852 acx_s_set_beacon_template(adev
, adev
->beacon_cache
);
3853 dev_kfree_skb(adev
->beacon_cache
);
3854 adev
->beacon_cache
= NULL
;
3856 CLEAR_BIT(adev
->set_mask
, SET_TEMPLATES
);
3859 if (adev
->set_mask
& SET_RXCONFIG
) {
3860 acx_s_initialize_rx_config(adev
);
3861 CLEAR_BIT(adev
->set_mask
, SET_RXCONFIG
);
3864 if (adev
->set_mask
& GETSET_RESCAN
) {
3865 /* switch (adev->mode) {
3866 case ACX_MODE_0_ADHOC:
3867 case ACX_MODE_2_STA:
3871 */ CLEAR_BIT(adev
->set_mask
, GETSET_RESCAN
);
3874 if (adev
->set_mask
& GETSET_WEP
) {
3877 ie_dot11WEPDefaultKeyID_t dkey
;
3883 } ACX_PACKED keyindic
;
3885 log(L_INIT
, "updating WEP key settings\n");
3887 acx_s_set_wepkey(adev
);
3888 if (adev
->wep_enabled
) {
3889 dkey
.KeyID
= adev
->wep_current_index
;
3890 log(L_INIT
, "setting WEP key %u as default\n",
3892 acx_s_configure(adev
, &dkey
,
3893 ACX1xx_IE_DOT11_WEP_DEFAULT_KEY_SET
);
3896 acx_s_configure(adev
, &keyindic
, ACX111_IE_KEY_CHOOSE
);
3901 CLEAR_BIT(adev
->set_mask
, GETSET_WEP
);
3904 if (adev
->set_mask
& SET_WEP_OPTIONS
) {
3905 acx100_ie_wep_options_t options
;
3907 if (IS_ACX111(adev
)) {
3909 "setting WEP Options for acx111 is not supported\n");
3911 log(L_INIT
, "setting WEP Options\n");
3913 /* let's choose maximum setting: 4 default keys,
3914 * plus 10 other keys: */
3916 cpu_to_le16(DOT11_MAX_DEFAULT_WEP_KEYS
+ 10);
3917 /* don't decrypt default key only,
3918 * don't override decryption: */
3919 options
.WEPOption
= 0;
3920 if (adev
->mode
== ACX_MODE_3_AP
) {
3921 /* don't decrypt default key only,
3922 * override decryption mechanism: */
3923 options
.WEPOption
= 2;
3926 acx_s_configure(adev
, &options
, ACX100_IE_WEP_OPTIONS
);
3928 CLEAR_BIT(adev
->set_mask
, SET_WEP_OPTIONS
);
3932 /* debug, rate, and nick don't need any handling */
3933 /* what about sniffing mode?? */
3935 /* log(L_INIT, "get_mask 0x%08X, set_mask 0x%08X - after update\n",
3936 adev->get_mask, adev->set_mask);
3943 /***********************************************************************
3944 ** acx_e_after_interrupt_task
3946 static int acx_s_recalib_radio(acx_device_t
* adev
)
3948 if (IS_ACX111(adev
)) {
3949 acx111_cmd_radiocalib_t cal
;
3951 /* automatic recalibration, choose all methods: */
3952 cal
.methods
= cpu_to_le32(0x8000000f);
3953 /* automatic recalibration every 60 seconds (value in TUs)
3954 * I wonder what the firmware default here is? */
3955 cal
.interval
= cpu_to_le32(58594);
3956 return acx_s_issue_cmd_timeo(adev
, ACX111_CMD_RADIOCALIB
,
3958 CMD_TIMEOUT_MS(100));
3960 /* On ACX100, we need to recalibrate the radio
3961 * by issuing a GETSET_TX|GETSET_RX */
3962 if ( /* (OK == acx_s_issue_cmd(adev, ACX1xx_CMD_DISABLE_TX, NULL, 0)) &&
3963 (OK == acx_s_issue_cmd(adev, ACX1xx_CMD_DISABLE_RX, NULL, 0)) && */
3965 acx_s_issue_cmd(adev
, ACX1xx_CMD_ENABLE_TX
,
3968 acx_s_issue_cmd(adev
, ACX1xx_CMD_ENABLE_RX
,
3969 &adev
->channel
, 1)))
3976 static void acx_s_after_interrupt_recalib(acx_device_t
* adev
)
3980 /* this helps with ACX100 at least;
3981 * hopefully ACX111 also does a
3982 * recalibration here */
3984 /* clear flag beforehand, since we want to make sure
3985 * it's cleared; then only set it again on specific circumstances */
3986 CLEAR_BIT(adev
->after_interrupt_jobs
, ACX_AFTER_IRQ_CMD_RADIO_RECALIB
);
3988 /* better wait a bit between recalibrations to
3989 * prevent overheating due to torturing the card
3990 * into working too long despite high temperature
3991 * (just a safety measure) */
3992 if (adev
->recalib_time_last_success
3993 && time_before(jiffies
, adev
->recalib_time_last_success
3994 + RECALIB_PAUSE
* 60 * HZ
)) {
3995 if (adev
->recalib_msg_ratelimit
<= 4) {
3996 printk("%s: less than " STRING(RECALIB_PAUSE
)
3997 " minutes since last radio recalibration, "
3998 "not recalibrating (maybe card is too hot?)\n",
3999 wiphy_name(adev
->ieee
->wiphy
));
4000 adev
->recalib_msg_ratelimit
++;
4001 if (adev
->recalib_msg_ratelimit
== 5)
4002 printk("disabling above message until next recalib\n");
4007 adev
->recalib_msg_ratelimit
= 0;
4009 /* note that commands sometimes fail (card busy),
4010 * so only clear flag if we were fully successful */
4011 res
= acx_s_recalib_radio(adev
);
4013 printk("%s: successfully recalibrated radio\n",
4014 wiphy_name(adev
->ieee
->wiphy
));
4015 adev
->recalib_time_last_success
= jiffies
;
4016 adev
->recalib_failure_count
= 0;
4018 /* failed: resubmit, but only limited
4019 * amount of times within some time range
4020 * to prevent endless loop */
4022 adev
->recalib_time_last_success
= 0; /* we failed */
4024 /* if some time passed between last
4025 * attempts, then reset failure retry counter
4026 * to be able to do next recalib attempt */
4028 (jiffies
, adev
->recalib_time_last_attempt
+ 5 * HZ
))
4029 adev
->recalib_failure_count
= 0;
4031 if (adev
->recalib_failure_count
< 5) {
4032 /* increment inside only, for speedup of outside path */
4033 adev
->recalib_failure_count
++;
4034 adev
->recalib_time_last_attempt
= jiffies
;
4035 acx_schedule_task(adev
,
4036 ACX_AFTER_IRQ_CMD_RADIO_RECALIB
);
4042 void acx_e_after_interrupt_task(struct work_struct
*work
)
4044 acx_device_t
*adev
= container_of(work
, acx_device_t
, after_interrupt_task
);
4045 unsigned long flags
;
4049 acx_lock(adev
, flags
);
4051 if (!adev
->after_interrupt_jobs
|| !adev
->initialized
)
4052 goto end
; /* no jobs to do */
4054 /* we see lotsa tx errors */
4055 if (adev
->after_interrupt_jobs
& ACX_AFTER_IRQ_CMD_RADIO_RECALIB
) {
4056 // acx_s_after_interrupt_recalib(adev);
4059 /* a poor interrupt code wanted to do update_card_settings() */
4060 if (adev
->after_interrupt_jobs
& ACX_AFTER_IRQ_UPDATE_CARD_CFG
) {
4061 if (ACX_STATE_IFACE_UP
& adev
->dev_state_mask
) {
4062 acx_unlock(adev
, flags
);
4063 acx_s_update_card_settings(adev
);
4064 acx_lock(adev
, flags
);
4066 CLEAR_BIT(adev
->after_interrupt_jobs
,
4067 ACX_AFTER_IRQ_UPDATE_CARD_CFG
);
4070 /* 1) we detected that no Scan_Complete IRQ came from fw, or
4071 ** 2) we found too many STAs */
4072 if (adev
->after_interrupt_jobs
& ACX_AFTER_IRQ_CMD_STOP_SCAN
) {
4073 log(L_IRQ
, "sending a stop scan cmd...\n");
4074 acx_s_issue_cmd(adev
, ACX1xx_CMD_STOP_SCAN
, NULL
, 0);
4075 /* HACK: set the IRQ bit, since we won't get a
4076 * scan complete IRQ any more on ACX111 (works on ACX100!),
4077 * since _we_, not a fw, have stopped the scan */
4078 SET_BIT(adev
->irq_status
, HOST_INT_SCAN_COMPLETE
);
4079 CLEAR_BIT(adev
->after_interrupt_jobs
,
4080 ACX_AFTER_IRQ_CMD_STOP_SCAN
);
4083 /* either fw sent Scan_Complete or we detected that
4084 ** no Scan_Complete IRQ came from fw. Finish scanning,
4085 ** pick join partner if any */
4086 if (adev
->after_interrupt_jobs
& ACX_AFTER_IRQ_COMPLETE_SCAN
) {
4087 /* + scan kills current join status - restore it
4088 ** (do we need it for STA?) */
4089 /* + does it happen only with active scans?
4090 ** active and passive scans? ALL scans including
4091 ** background one? */
4092 /* + was not verified that everything is restored
4093 ** (but at least we start to emit beacons again) */
4094 CLEAR_BIT(adev
->after_interrupt_jobs
,
4095 ACX_AFTER_IRQ_COMPLETE_SCAN
);
4098 /* STA auth or assoc timed out, start over again */
4100 if (adev
->after_interrupt_jobs
& ACX_AFTER_IRQ_RESTART_SCAN
) {
4101 log(L_IRQ
, "sending a start_scan cmd...\n");
4102 CLEAR_BIT(adev
->after_interrupt_jobs
,
4103 ACX_AFTER_IRQ_RESTART_SCAN
);
4106 /* whee, we got positive assoc response! 8) */
4107 if (adev
->after_interrupt_jobs
& ACX_AFTER_IRQ_CMD_ASSOCIATE
) {
4108 CLEAR_BIT(adev
->after_interrupt_jobs
,
4109 ACX_AFTER_IRQ_CMD_ASSOCIATE
);
4112 if(adev
->after_interrupt_jobs
)
4114 printk("Jobs still to be run: %x\n",adev
->after_interrupt_jobs
);
4115 adev
->after_interrupt_jobs
= 0;
4117 acx_unlock(adev
, flags
);
4118 // acx_sem_unlock(adev);
4123 /***********************************************************************
4124 ** acx_schedule_task
4126 ** Schedule the call of the after_interrupt method after leaving
4127 ** the interrupt context.
4129 void acx_schedule_task(acx_device_t
* adev
, unsigned int set_flag
)
4131 if (!adev
->after_interrupt_jobs
)
4133 SET_BIT(adev
->after_interrupt_jobs
, set_flag
);
4134 schedule_work(&adev
->after_interrupt_task
);
4139 /***********************************************************************
4141 void acx_init_task_scheduler(acx_device_t
* adev
)
4143 /* configure task scheduler */
4144 INIT_WORK(&adev
->after_interrupt_task
, acx_interrupt_tasklet
);
4148 /***********************************************************************
4151 void acx_s_start(acx_device_t
* adev
)
4156 * Ok, now we do everything that can possibly be done with ioctl
4157 * calls to make sure that when it was called before the card
4158 * was up we get the changes asked for
4161 SET_BIT(adev
->set_mask
, SET_TEMPLATES
| SET_STA_LIST
| GETSET_WEP
4162 | GETSET_TXPOWER
| GETSET_ANTENNA
| GETSET_ED_THRESH
|
4163 GETSET_CCA
| GETSET_REG_DOMAIN
| GETSET_MODE
| GETSET_CHANNEL
|
4164 GETSET_TX
| GETSET_RX
| GETSET_STATION_ID
);
4166 log(L_INIT
, "updating initial settings on iface activation\n");
4167 acx_s_update_card_settings(adev
);
4173 /***********************************************************************
4174 ** acx_update_capabilities
4176 void acx_update_capabilities(acx_device_t * adev)
4180 switch (adev->mode) {
4182 SET_BIT(cap, WF_MGMT_CAP_ESS);
4184 case ACX_MODE_0_ADHOC:
4185 SET_BIT(cap, WF_MGMT_CAP_IBSS);
4187 */ /* other types of stations do not emit beacons */
4190 if (adev->wep_restricted) {
4191 SET_BIT(cap, WF_MGMT_CAP_PRIVACY);
4193 if (adev->cfgopt_dot11ShortPreambleOption) {
4194 SET_BIT(cap, WF_MGMT_CAP_SHORT);
4196 if (adev->cfgopt_dot11PBCCOption) {
4197 SET_BIT(cap, WF_MGMT_CAP_PBCC);
4199 if (adev->cfgopt_dot11ChannelAgility) {
4200 SET_BIT(cap, WF_MGMT_CAP_AGILITY);
4202 log(L_DEBUG, "caps updated from 0x%04X to 0x%04X\n",
4203 adev->capabilities, cap);
4204 adev->capabilities = cap;
4208 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4211 static void acx_select_opmode(acx_device_t
* adev
)
4216 if (adev
->interface
.operating
) {
4217 switch (adev
->interface
.type
) {
4218 case IEEE80211_IF_TYPE_AP
:
4219 if (adev
->mode
!= ACX_MODE_3_AP
)
4221 adev
->mode
= ACX_MODE_3_AP
;
4225 case IEEE80211_IF_TYPE_IBSS
:
4226 if (adev
->mode
!= ACX_MODE_0_ADHOC
)
4228 adev
->mode
= ACX_MODE_0_ADHOC
;
4232 case IEEE80211_IF_TYPE_STA
:
4233 if (adev
->mode
!= ACX_MODE_2_STA
)
4235 adev
->mode
= ACX_MODE_2_STA
;
4239 case IEEE80211_IF_TYPE_WDS
:
4241 if (adev
->mode
!= ACX_MODE_OFF
)
4243 adev
->mode
= ACX_MODE_OFF
;
4249 if (adev
->interface
.type
== IEEE80211_IF_TYPE_MNTR
)
4251 if (adev
->mode
!= ACX_MODE_MONITOR
)
4253 adev
->mode
= ACX_MODE_MONITOR
;
4259 if (adev
->mode
!= ACX_MODE_OFF
)
4261 adev
->mode
= ACX_MODE_OFF
;
4268 SET_BIT(adev
->set_mask
, GETSET_MODE
);
4269 acx_s_update_card_settings(adev
);
4270 // acx_schedule_task(adev, ACX_AFTER_IRQ_UPDATE_CARD_CFG);
4277 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4281 int acx_add_interface(struct ieee80211_hw
*ieee
,
4282 struct ieee80211_if_init_conf
*conf
)
4284 acx_device_t
*adev
= ieee2adev(ieee
);
4285 unsigned long flags
;
4286 int err
= -EOPNOTSUPP
;
4288 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
4289 DECLARE_MAC_BUF(mac
);
4293 acx_lock(adev
, flags
);
4295 if (conf
->type
== IEEE80211_IF_TYPE_MNTR
) {
4296 adev
->interface
.monitor
++;
4298 if (adev
->interface
.operating
)
4300 adev
->interface
.operating
= 1;
4302 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
4303 adev
->vif
= conf
->vif
;
4305 adev
->interface
.if_id
= conf
->if_id
;
4308 adev
->interface
.mac_addr
= conf
->mac_addr
;
4309 adev
->interface
.type
= conf
->type
;
4311 // adev->mode = conf->type;
4313 acx_unlock(adev
, flags
);
4315 if (adev
->initialized
)
4316 acx_select_opmode(adev
);
4319 acx_lock(adev
, flags
);
4321 printk(KERN_INFO
"Virtual interface added "
4322 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
4323 "(type: 0x%08X), ID: %pd, MAC: %s\n",
4326 print_mac(mac
, conf
->mac_addr
));
4328 "(type: 0x%08X, ID: %d, MAC: %s)\n",
4331 print_mac(mac
, conf
->mac_addr
));
4335 acx_unlock(adev
, flags
);
4341 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4345 void acx_remove_interface(struct ieee80211_hw
*hw
,
4346 struct ieee80211_if_init_conf
*conf
)
4348 acx_device_t
*adev
= ieee2adev(hw
);
4349 unsigned long flags
;
4351 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
4352 DECLARE_MAC_BUF(mac
);
4357 acx_lock(adev
, flags
);
4358 if (conf
->type
== IEEE80211_IF_TYPE_MNTR
) {
4359 adev
->interface
.monitor
--;
4360 // assert(bcm->interface.monitor >= 0);
4362 adev
->interface
.operating
= 0;
4364 printk("Removing interface: %d %d\n", adev
->interface
.operating
, conf
->type
);
4365 acx_unlock(adev
, flags
);
4367 if (adev
->initialized
)
4368 acx_select_opmode(adev
);
4369 flush_scheduled_work();
4371 printk(KERN_INFO
"Virtual interface removed "
4372 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
4373 "(type: 0x%08X, ID: %pd, MAC: %s)\n",
4376 print_mac(mac
, conf
->mac_addr
));
4379 "(type: 0x%08X, ID: %d, MAC: %s)\n",
4380 conf
->type
, conf
->if_id
, print_mac(mac
, conf
->mac_addr
));
4385 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4389 int acx_net_reset(struct ieee80211_hw
*ieee
)
4391 acx_device_t
*adev
= ieee2adev(ieee
);
4394 acxpci_s_reset_dev(adev
);
4403 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4406 int acx_selectchannel(acx_device_t
* adev
, u8 channel
, int freq
)
4413 adev
->rx_status
.channel
= channel
;
4414 adev
->rx_status
.freq
= freq
;
4416 adev
->channel
= channel
;
4417 /* hmm, the following code part is strange, but this is how
4418 * it was being done before... */
4419 log(L_IOCTL
, "Changing to channel %d\n", channel
);
4420 SET_BIT(adev
->set_mask
, GETSET_CHANNEL
);
4421 result
= -EINPROGRESS
; /* need to call commit handler */
4423 acx_sem_unlock(adev
);
4429 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4432 int acx_net_config(struct ieee80211_hw
*hw
, struct ieee80211_conf
*conf
)
4434 acx_device_t
*adev
= ieee2adev(hw
);
4435 unsigned long flags
;
4441 acx_lock(adev
, flags
);
4443 if (!adev
->initialized
) {
4444 acx_unlock(adev
, flags
);
4447 if (conf
->beacon_int
!= adev
->beacon_interval
)
4448 adev
->beacon_interval
= conf
->beacon_int
;
4449 if (conf
->channel
!= adev
->channel
) {
4450 acx_unlock(adev
, flags
);
4451 acx_selectchannel(adev
, conf
->channel
,conf
->freq
);
4452 acx_lock(adev
, flags
);
4453 /* acx_schedule_task(adev,
4454 ACX_AFTER_IRQ_UPDATE_CARD_CFG
4455 */ /*+ ACX_AFTER_IRQ_RESTART_SCAN */ /*);*/
4458 if (conf->short_slot_time != adev->short_slot) {
4459 // assert(phy->type == BCM43xx_PHYTYPE_G);
4460 if (conf->short_slot_time)
4461 acx_short_slot_timing_enable(adev);
4463 acx_short_slot_timing_disable(adev);
4464 acx_schedule_task(adev, ACX_AFTER_IRQ_UPDATE_CARD_CFG);
4467 adev
->tx_disabled
= !conf
->radio_enabled
;
4468 /* if (conf->power_level != 0){
4469 adev->tx_level_dbm = conf->power_level;
4470 acx_s_set_tx_level(adev, adev->tx_level_dbm);
4471 SET_BIT(adev->set_mask,GETSET_TXPOWER);
4472 //acx_schedule_task(adev, ACX_AFTER_IRQ_UPDATE_CARD_CFG);
4475 //FIXME: This does not seem to wake up:
4477 if (conf
->power_level
== 0) {
4479 bcm43xx_radio_turn_off(bcm
);
4481 if (!radio
->enabled
)
4482 bcm43xx_radio_turn_on(bcm
);
4488 if (adev
->set_mask
> 0) {
4489 acx_unlock(adev
, flags
);
4490 acx_s_update_card_settings(adev
);
4491 acx_lock(adev
, flags
);
4493 acx_unlock(adev
, flags
);
4500 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4504 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
4505 extern int acx_config_interface(struct ieee80211_hw
* ieee
,
4506 struct ieee80211_vif
*vif
,
4507 struct ieee80211_if_conf
*conf
)
4509 acx_device_t
*adev
= ieee2adev(ieee
);
4510 unsigned long flags
;
4513 if (!adev
->interface
.operating
)
4515 acx_lock(adev
, flags
);
4517 if (adev
->initialized
)
4518 acx_select_opmode(adev
);
4520 if ((conf
->type
!= IEEE80211_IF_TYPE_MNTR
)
4521 && (adev
->vif
== vif
)) {
4524 adev
->interface
.bssid
= conf
->bssid
;
4525 MAC_COPY(adev
->bssid
,conf
->bssid
);
4528 if ((conf
->type
== IEEE80211_IF_TYPE_AP
)
4529 && (adev
->vif
== vif
)) {
4531 int acx_config_interface(struct ieee80211_hw
* ieee
, int if_id
,
4532 struct ieee80211_if_conf
*conf
)
4534 acx_device_t
*adev
= ieee2adev(ieee
);
4535 unsigned long flags
;
4538 if (!adev
->interface
.operating
)
4541 if (adev
->initialized
)
4542 acx_select_opmode(adev
);
4544 acx_lock(adev
, flags
);
4546 if ((conf
->type
!= IEEE80211_IF_TYPE_MNTR
)
4547 && (adev
->interface
.if_id
== if_id
)) {
4550 adev
->interface
.bssid
= conf
->bssid
;
4551 MAC_COPY(adev
->bssid
,conf
->bssid
);
4554 if ((conf
->type
== IEEE80211_IF_TYPE_AP
)
4555 && (adev
->interface
.if_id
== if_id
)) {
4558 if ((conf
->ssid_len
> 0) && conf
->ssid
)
4560 adev
->essid_len
= conf
->ssid_len
;
4561 memcpy(adev
->essid
, conf
->ssid
, conf
->ssid_len
);
4562 SET_BIT(adev
->set_mask
, SET_TEMPLATES
);
4565 if (conf
->beacon
!= 0)
4567 adev
->beacon_interval
= DEFAULT_BEACON_INTERVAL
;
4568 adev
->beacon_cache
= conf
->beacon
;
4569 SET_BIT(adev
->set_mask
, SET_TEMPLATES
);
4571 if (adev
->set_mask
!= 0)
4572 acx_s_update_card_settings(adev
);
4573 // acx_schedule_task(adev, ACX_AFTER_IRQ_UPDATE_CARD_CFG);
4574 acx_unlock(adev
, flags
);
4582 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4586 int acx_net_get_tx_stats(struct ieee80211_hw
*hw
,
4587 struct ieee80211_tx_queue_stats
*stats
)
4589 // acx_device_t *adev = ndev2adev(net_dev);
4590 struct ieee80211_tx_queue_stats_data
*data
;
4595 // acx_lock(adev, flags);
4596 data
= &(stats
->data
[0]);
4598 data
->limit
= TX_CNT
;
4600 // acx_unlock(adev, flags);
4606 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4610 int acx_net_conf_tx(struct ieee80211_hw
*hw
,
4611 int queue
, const struct ieee80211_tx_queue_params
*params
)
4619 static void keymac_write(acx_device_t
* adev
, u16 index
, const u32
* addr
)
4621 /* for keys 0-3 there is no associated mac address */
4629 bcm43xx_shm_write32(bcm,
4632 cpu_to_be32(*addr));
4633 bcm43xx_shm_write16(bcm,
4636 cpu_to_be16(*((u16 *)(addr + 1))));
4640 TODO(); /* Put them in the macaddress filter */
4643 /* Put them BCM43xx_SHM_SHARED, stating index 0x0120.
4644 Keep in mind to update the count of keymacs in 0x003 */
4650 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4654 int acx_clear_keys(acx_device_t
* adev
)
4656 static const u32 zero_mac
[2] = { 0 };
4657 unsigned int i
, j
, nr_keys
= 54;
4660 /* FixMe:Check for Number of Keys available */
4662 // assert(nr_keys <= ARRAY_SIZE(adev->key));
4664 for (i
= 0; i
< nr_keys
; i
++) {
4665 adev
->key
[i
].enabled
= 0;
4666 /* returns for i < 4 immediately */
4667 keymac_write(adev
, i
, zero_mac
);
4669 bcm43xx_shm_write16(adev, BCM43xx_SHM_SHARED,
4670 0x100 + (i * 2), 0x0000);
4672 for (j
= 0; j
< 8; j
++) {
4674 adev
->security_offset
+ (j
* 4) +
4675 (i
* ACX_SEC_KEYSIZE
);
4677 bcm43xx_shm_write16(bcm, BCM43xx_SHM_SHARED,
4686 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4690 int acx_key_write(acx_device_t
* adev
,
4691 u16 index
, u8 algorithm
,
4692 const struct ieee80211_key_conf
*key
, const u8
* mac_addr
)
4694 // struct iw_point *dwrq = &wrqu->encoding;
4699 log(L_IOCTL, "set encoding flags=0x%04X, size=%d, key: %s\n",
4700 dwrq->flags, dwrq->length, extra ? "set" : "No key");
4702 // acx_sem_lock(adev);
4704 // index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
4705 if (key
->keylen
> 0) {
4706 /* if index is 0 or invalid, use default key */
4708 index
= (int)adev
->wep_current_index
;
4709 if ((algorithm
== ACX_SEC_ALGO_WEP
) ||
4710 (algorithm
== ACX_SEC_ALGO_WEP104
)) {
4711 switch(key
->keylen
) {
4714 40-bit entered key + 24 bit IV = 64-bit */
4715 adev
->wep_keys
[index
].size
= 13;
4719 104-bit entered key + 24-bit IV = 128-bit */
4720 adev
->wep_keys
[index
].size
= 29;
4724 128-bit entered key + 24 bit IV = 152-bit */
4725 adev
->wep_keys
[index
].size
= 16;
4728 adev
->wep_keys
[index
].size
= 0;
4729 return -EINVAL
; /* shouldn't happen */
4732 memset(adev
->wep_keys
[index
].key
, 0,
4733 sizeof(adev
->wep_keys
[index
].key
));
4734 memcpy(adev
->wep_keys
[index
].key
, key
, key
->keylen
);
4736 /* set transmit key */
4738 adev
->wep_current_index
= index
;
4739 // else if (0 == (dwrq->flags & IW_ENCODE_MODE)) {
4740 /* complain if we were not just setting
4742 // result = -EINVAL;
4748 adev
->wep_enabled
= (algorithm
== ALG_WEP
);
4750 adev->wep_enabled = !(dwrq->flags & IW_ENCODE_DISABLED);
4752 if (algorithm & IW_ENCODE_OPEN) {
4753 adev->auth_alg = WLAN_AUTH_ALG_OPENSYSTEM;
4754 adev->wep_restricted = 0;
4756 } else if (algorithm & IW_ENCODE_RESTRICTED) {
4757 adev->auth_alg = WLAN_AUTH_ALG_SHAREDKEY;
4758 adev->wep_restricted = 1;
4761 // adev->auth_alg = algorithm;
4762 /* set flag to make sure the card WEP settings get updated */
4763 if (adev
->wep_enabled
) {
4764 SET_BIT(adev
->set_mask
, GETSET_WEP
);
4765 acx_s_update_card_settings(adev
);
4766 // acx_schedule_task(adev, ACX_AFTER_IRQ_UPDATE_CARD_CFG);
4769 log(L_IOCTL, "len=%d, key at 0x%p, flags=0x%X\n",
4770 dwrq->length, extra, dwrq->flags);
4771 for (index = 0; index <= 3; index++) {
4772 if (adev->wep_keys[index].size) {
4773 log(L_IOCTL, "index=%d, size=%d, key at 0x%p\n",
4774 adev->wep_keys[index].index,
4775 (int) adev->wep_keys[index].size,
4776 adev->wep_keys[index].key);
4780 result
= -EINPROGRESS
;
4781 // acx_sem_unlock(adev);
4790 ** Derived from mac80211 code, p54, bcm43xx_mac80211
4794 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
4795 int acx_net_set_key(struct ieee80211_hw
*ieee
,
4797 u8
* addr
, struct ieee80211_key_conf
*key
, int aid
)
4799 int acx_net_set_key(struct ieee80211_hw
*ieee
,
4800 enum set_key_cmd cmd
, const u8
*local_addr
,
4801 const u8
* addr
, struct ieee80211_key_conf
*key
)
4805 struct acx_device
*adev
= ieee2adev(ieee
);
4806 unsigned long flags
;
4816 algorithm = ACX_SEC_ALGO_NONE;
4819 if (key
->keylen
== 5)
4820 algorithm
= ACX_SEC_ALGO_WEP
;
4822 algorithm
= ACX_SEC_ALGO_WEP104
;
4825 algorithm
= ACX_SEC_ALGO_TKIP
;
4828 algorithm
= ACX_SEC_ALGO_AES
;
4832 index
= (u8
) (key
->keyidx
);
4833 if (index
>= ARRAY_SIZE(adev
->key
))
4835 acx_lock(adev
, flags
);
4838 err
= acx_key_write(adev
, index
, algorithm
, key
, addr
);
4841 key
->hw_key_idx
= index
;
4842 /* CLEAR_BIT(key->flags, IEEE80211_KEY_FORCE_SW_ENCRYPT);*/
4843 /* if (CHECK_BIT(key->flags, IEEE80211_KEY_DEFAULT_TX_KEY))
4844 adev->default_key_idx = index;*/
4845 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
4846 SET_BIT(key
->flags
, IEEE80211_KEY_FLAG_GENERATE_IV
);
4848 adev
->key
[index
].enabled
= 1;
4851 adev
->key
[index
].enabled
= 0;
4854 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
4855 case REMOVE_ALL_KEYS
:
4856 acx_clear_keys(adev
);
4860 /* case ENABLE_COMPRESSION:
4861 case DISABLE_COMPRESSION:
4866 acx_unlock(adev
, flags
);
4874 /***********************************************************************
4875 ** Common function to parse ALL configoption struct formats
4876 ** (ACX100 and ACX111; FIXME: how to make it work with ACX100 USB!?!?).
4877 ** FIXME: logging should be removed here and added to a /proc file instead
4879 ** Look into bcm43xx
4882 acx_s_parse_configoption(acx_device_t
* adev
,
4883 const acx111_ie_configoption_t
* pcfg
)
4887 int is_acx111
= IS_ACX111(adev
);
4889 if (acx_debug
& L_DEBUG
) {
4890 printk("configoption struct content:\n");
4891 acx_dump_bytes(pcfg
, sizeof(*pcfg
));
4894 if ((is_acx111
&& (adev
->eeprom_version
== 5))
4895 || (!is_acx111
&& (adev
->eeprom_version
== 4))
4896 || (!is_acx111
&& (adev
->eeprom_version
== 5))) {
4897 /* these versions are known to be supported */
4899 printk("unknown chip and EEPROM version combination (%s, v%d), "
4900 "don't know how to parse config options yet. "
4901 "Please report\n", is_acx111
? "ACX111" : "ACX100",
4902 adev
->eeprom_version
);
4906 /* first custom-parse the first part which has chip-specific layout */
4908 pEle
= (const u8
*)pcfg
;
4910 pEle
+= 4; /* skip (type,len) header */
4912 memcpy(adev
->cfgopt_NVSv
, pEle
, sizeof(adev
->cfgopt_NVSv
));
4913 pEle
+= sizeof(adev
->cfgopt_NVSv
);
4916 adev
->cfgopt_NVS_vendor_offs
= le16_to_cpu(*(u16
*) pEle
);
4917 pEle
+= sizeof(adev
->cfgopt_NVS_vendor_offs
);
4919 adev
->cfgopt_probe_delay
= 200; /* good default value? */
4920 pEle
+= 2; /* FIXME: unknown, value 0x0001 */
4922 memcpy(adev
->cfgopt_MAC
, pEle
, sizeof(adev
->cfgopt_MAC
));
4923 pEle
+= sizeof(adev
->cfgopt_MAC
);
4925 adev
->cfgopt_probe_delay
= le16_to_cpu(*(u16
*) pEle
);
4926 pEle
+= sizeof(adev
->cfgopt_probe_delay
);
4927 if ((adev
->cfgopt_probe_delay
< 100)
4928 || (adev
->cfgopt_probe_delay
> 500)) {
4929 printk("strange probe_delay value %d, "
4930 "tweaking to 200\n", adev
->cfgopt_probe_delay
);
4931 adev
->cfgopt_probe_delay
= 200;
4935 adev
->cfgopt_eof_memory
= le32_to_cpu(*(u32
*) pEle
);
4936 pEle
+= sizeof(adev
->cfgopt_eof_memory
);
4938 printk("NVS_vendor_offs:%04X probe_delay:%d eof_memory:%d\n",
4939 adev
->cfgopt_NVS_vendor_offs
,
4940 adev
->cfgopt_probe_delay
, adev
->cfgopt_eof_memory
);
4942 adev
->cfgopt_dot11CCAModes
= *pEle
++;
4943 adev
->cfgopt_dot11Diversity
= *pEle
++;
4944 adev
->cfgopt_dot11ShortPreambleOption
= *pEle
++;
4945 adev
->cfgopt_dot11PBCCOption
= *pEle
++;
4946 adev
->cfgopt_dot11ChannelAgility
= *pEle
++;
4947 adev
->cfgopt_dot11PhyType
= *pEle
++;
4948 adev
->cfgopt_dot11TempType
= *pEle
++;
4949 printk("CCAModes:%02X Diversity:%02X ShortPreOpt:%02X "
4950 "PBCC:%02X ChanAgil:%02X PHY:%02X Temp:%02X\n",
4951 adev
->cfgopt_dot11CCAModes
,
4952 adev
->cfgopt_dot11Diversity
,
4953 adev
->cfgopt_dot11ShortPreambleOption
,
4954 adev
->cfgopt_dot11PBCCOption
,
4955 adev
->cfgopt_dot11ChannelAgility
,
4956 adev
->cfgopt_dot11PhyType
, adev
->cfgopt_dot11TempType
);
4958 /* then use common parsing for next part which has common layout */
4960 pEle
++; /* skip table_count (6) */
4962 adev
->cfgopt_antennas
.type
= pEle
[0];
4963 adev
->cfgopt_antennas
.len
= pEle
[1];
4964 printk("AntennaID:%02X Len:%02X Data:",
4965 adev
->cfgopt_antennas
.type
, adev
->cfgopt_antennas
.len
);
4966 for (i
= 0; i
< pEle
[1]; i
++) {
4967 adev
->cfgopt_antennas
.list
[i
] = pEle
[i
+ 2];
4968 printk("%02X ", pEle
[i
+ 2]);
4972 pEle
+= pEle
[1] + 2;
4973 adev
->cfgopt_power_levels
.type
= pEle
[0];
4974 adev
->cfgopt_power_levels
.len
= pEle
[1];
4975 printk("PowerLevelID:%02X Len:%02X Data:",
4976 adev
->cfgopt_power_levels
.type
, adev
->cfgopt_power_levels
.len
);
4977 for (i
= 0; i
< pEle
[1]; i
++) {
4978 adev
->cfgopt_power_levels
.list
[i
] =
4979 le16_to_cpu(*(u16
*) & pEle
[i
* 2 + 2]);
4980 printk("%04X ", adev
->cfgopt_power_levels
.list
[i
]);
4984 pEle
+= pEle
[1] * 2 + 2;
4985 adev
->cfgopt_data_rates
.type
= pEle
[0];
4986 adev
->cfgopt_data_rates
.len
= pEle
[1];
4987 printk("DataRatesID:%02X Len:%02X Data:",
4988 adev
->cfgopt_data_rates
.type
, adev
->cfgopt_data_rates
.len
);
4989 for (i
= 0; i
< pEle
[1]; i
++) {
4990 adev
->cfgopt_data_rates
.list
[i
] = pEle
[i
+ 2];
4991 printk("%02X ", pEle
[i
+ 2]);
4995 pEle
+= pEle
[1] + 2;
4996 adev
->cfgopt_domains
.type
= pEle
[0];
4997 adev
->cfgopt_domains
.len
= pEle
[1];
4998 printk("DomainID:%02X Len:%02X Data:",
4999 adev
->cfgopt_domains
.type
, adev
->cfgopt_domains
.len
);
5000 for (i
= 0; i
< pEle
[1]; i
++) {
5001 adev
->cfgopt_domains
.list
[i
] = pEle
[i
+ 2];
5002 printk("%02X ", pEle
[i
+ 2]);
5006 pEle
+= pEle
[1] + 2;
5007 adev
->cfgopt_product_id
.type
= pEle
[0];
5008 adev
->cfgopt_product_id
.len
= pEle
[1];
5009 for (i
= 0; i
< pEle
[1]; i
++) {
5010 adev
->cfgopt_product_id
.list
[i
] = pEle
[i
+ 2];
5012 printk("ProductID:%02X Len:%02X Data:%.*s\n",
5013 adev
->cfgopt_product_id
.type
, adev
->cfgopt_product_id
.len
,
5014 adev
->cfgopt_product_id
.len
,
5015 (char *)adev
->cfgopt_product_id
.list
);
5017 pEle
+= pEle
[1] + 2;
5018 adev
->cfgopt_manufacturer
.type
= pEle
[0];
5019 adev
->cfgopt_manufacturer
.len
= pEle
[1];
5020 for (i
= 0; i
< pEle
[1]; i
++) {
5021 adev
->cfgopt_manufacturer
.list
[i
] = pEle
[i
+ 2];
5023 printk("ManufacturerID:%02X Len:%02X Data:%.*s\n",
5024 adev
->cfgopt_manufacturer
.type
, adev
->cfgopt_manufacturer
.len
,
5025 adev
->cfgopt_manufacturer
.len
,
5026 (char *)adev
->cfgopt_manufacturer
.list
);
5028 printk("EEPROM part:\n");
5029 for (i=0; i<58; i++) {
5030 printk("%02X =======> 0x%02X\n",
5031 i, (u8 *)adev->cfgopt_NVSv[i-2]);
5037 /***********************************************************************
5038 ** Linux Kernel Specific
5040 static int __init
acx_e_init_module(void)
5044 acx_struct_size_check();
5046 printk("acx: this driver is still EXPERIMENTAL\n"
5047 "acx: reading README file and/or Craig's HOWTO is "
5048 "recommended, visit http://acx100.sourceforge.net/wiki in case "
5049 "of further questions/discussion\n");
5051 #if defined(CONFIG_ACX_MAC80211_PCI)
5052 r1
= acxpci_e_init_module();
5056 #if defined(CONFIG_ACX_MAC80211_USB)
5057 r2
= acxusb_e_init_module();
5061 if (r2
&& r1
) /* both failed! */
5062 return r2
? r2
: r1
;
5063 /* return success if at least one succeeded */
5067 static void __exit
acx_e_cleanup_module(void)
5069 #if defined(CONFIG_ACX_MAC80211_PCI)
5070 acxpci_e_cleanup_module();
5072 #if defined(CONFIG_ACX_MAC80211_USB)
5073 acxusb_e_cleanup_module();
5077 module_init(acx_e_init_module
)
5078 module_exit(acx_e_cleanup_module
)