This source file includes following definitions.
- snprint_line
- printk_buf
- snprintk_buf
- ipw_write_reg8
- ipw_write_reg16
- ipw_write_reg32
- _ipw_write8
- _ipw_write16
- _ipw_write32
- _ipw_read8
- _ipw_read16
- _ipw_read32
- _ipw_write_reg32
- _ipw_write_reg8
- _ipw_write_reg16
- _ipw_read_reg8
- _ipw_read_reg32
- _ipw_read_indirect
- _ipw_write_indirect
- ipw_write_direct
- ipw_set_bit
- ipw_clear_bit
- __ipw_enable_interrupts
- __ipw_disable_interrupts
- ipw_enable_interrupts
- ipw_disable_interrupts
- ipw_error_desc
- ipw_dump_error_log
- ipw_is_init
- ipw_get_ordinal
- ipw_init_ordinals
- ipw_register_toggle
- ipw_led_link_on
- ipw_bg_led_link_on
- ipw_led_link_off
- ipw_bg_led_link_off
- __ipw_led_activity_on
- ipw_led_activity_on
- ipw_led_activity_off
- ipw_bg_led_activity_off
- ipw_led_band_on
- ipw_led_band_off
- ipw_led_radio_on
- ipw_led_radio_off
- ipw_led_link_up
- ipw_led_link_down
- ipw_led_init
- ipw_led_shutdown
- debug_level_show
- debug_level_store
- ipw_get_event_log_len
- ipw_capture_event_log
- ipw_alloc_error_log
- show_event_log
- show_error
- clear_error
- show_cmd_log
- store_rtap_iface
- show_rtap_iface
- store_rtap_filter
- show_rtap_filter
- show_scan_age
- store_scan_age
- show_led
- store_led
- show_status
- show_cfg
- show_nic_type
- show_ucode_version
- show_rtc
- show_eeprom_delay
- store_eeprom_delay
- show_command_event_reg
- store_command_event_reg
- show_mem_gpio_reg
- store_mem_gpio_reg
- show_indirect_dword
- store_indirect_dword
- show_indirect_byte
- store_indirect_byte
- show_direct_dword
- store_direct_dword
- rf_kill_active
- show_rf_kill
- ipw_radio_kill_sw
- store_rf_kill
- show_speed_scan
- store_speed_scan
- show_net_stats
- store_net_stats
- show_channels
- notify_wx_assoc_event
- ipw_irq_tasklet
- get_cmd_string
- __ipw_send_cmd
- ipw_send_cmd_simple
- ipw_send_cmd_pdu
- ipw_send_host_complete
- ipw_send_system_config
- ipw_send_ssid
- ipw_send_adapter_address
- ipw_adapter_restart
- ipw_bg_adapter_restart
- ipw_scan_check
- ipw_bg_scan_check
- ipw_send_scan_request_ext
- ipw_send_scan_abort
- ipw_set_sensitivity
- ipw_send_associate
- ipw_send_supported_rates
- ipw_set_random_seed
- ipw_send_card_disable
- ipw_send_tx_power
- ipw_set_tx_power
- ipw_send_rts_threshold
- ipw_send_frag_threshold
- ipw_send_power_mode
- ipw_send_retry_limit
- eeprom_write_reg
- eeprom_cs
- eeprom_disable_cs
- eeprom_write_bit
- eeprom_op
- eeprom_read_u16
- eeprom_parse_mac
- ipw_read_eeprom
- ipw_eeprom_init_sram
- ipw_zero_memory
- ipw_fw_dma_reset_command_blocks
- ipw_fw_dma_enable
- ipw_fw_dma_abort
- ipw_fw_dma_write_command_block
- ipw_fw_dma_kick
- ipw_fw_dma_dump_command_block
- ipw_fw_dma_command_block_index
- ipw_fw_dma_add_command_block
- ipw_fw_dma_add_buffer
- ipw_fw_dma_wait
- ipw_remove_current_network
- ipw_alive
- ipw_poll_bit
- ipw_stop_master
- ipw_arc_release
- ipw_load_ucode
- ipw_load_firmware
- ipw_stop_nic
- ipw_start_nic
- ipw_init_nic
- ipw_reset_nic
- ipw_get_fw
- ipw_rx_queue_reset
- free_firmware
- ipw_load
- ipw_rx_queue_space
- ipw_tx_queue_space
- ipw_queue_inc_wrap
- ipw_queue_init
- ipw_queue_tx_init
- ipw_queue_tx_free_tfd
- ipw_queue_tx_free
- ipw_tx_queue_free
- ipw_create_bssid
- ipw_add_station
- ipw_find_station
- ipw_send_disassociate
- ipw_disassociate
- ipw_bg_disassociate
- ipw_system_config
- ipw_get_status_code
- average_init
- exponential_average
- average_add
- average_value
- ipw_reset_stats
- ipw_get_max_rate
- ipw_get_current_rate
- ipw_gather_stats
- ipw_bg_gather_stats
- ipw_handle_missed_beacon
- ipw_scan_event
- handle_scan_event
- ipw_rx_notification
- ipw_queue_reset
- ipw_queue_tx_reclaim
- ipw_queue_tx_hcmd
- ipw_rx_queue_restock
- ipw_rx_queue_replenish
- ipw_bg_rx_queue_replenish
- ipw_rx_queue_free
- ipw_rx_queue_alloc
- ipw_is_rate_in_mask
- ipw_compatible_rates
- ipw_copy_rates
- ipw_add_cck_scan_rates
- ipw_add_ofdm_scan_rates
- ipw_find_adhoc_network
- ipw_merge_adhoc_network
- ipw_best_network
- ipw_adhoc_create
- ipw_send_tgi_tx_key
- ipw_send_wep_keys
- ipw_set_hw_decrypt_unicast
- ipw_set_hw_decrypt_multicast
- ipw_set_hwcrypto_keys
- ipw_adhoc_check
- ipw_bg_adhoc_check
- ipw_debug_config
- ipw_set_fixed_rate
- ipw_abort_scan
- ipw_add_scan_channels
- ipw_passive_dwell_time
- ipw_request_scan_helper
- ipw_request_passive_scan
- ipw_request_scan
- ipw_request_direct_scan
- ipw_bg_abort_scan
- ipw_wpa_enable
- ipw_wpa_set_auth_algs
- ipw_wpa_assoc_frame
- ipw_set_rsn_capa
- ipw_wx_set_genie
- ipw_wx_get_genie
- wext_cipher2level
- ipw_wx_set_auth
- ipw_wx_get_auth
- ipw_wx_set_encodeext
- ipw_wx_get_encodeext
- ipw_wx_set_mlme
- ipw_qos_current_mode
- ipw_qos_handle_probe_response
- ipw_qos_activate
- ipw_qos_set_info_element
- ipw_qos_association
- ipw_qos_association_resp
- ipw_qos_get_burst_duration
- ipw_qos_init
- ipw_get_tx_queue_number
- ipw_is_qos_active
- ipw_qos_set_tx_queue_command
- ipw_bg_qos_activate
- ipw_handle_probe_response
- ipw_handle_beacon
- ipw_handle_assoc_response
- ipw_send_qos_params_command
- ipw_send_qos_info_command
- ipw_associate_network
- ipw_roam
- ipw_bg_roam
- ipw_associate
- ipw_bg_associate
- ipw_rebuild_decrypted_skb
- ipw_handle_data_packet
- ipw_handle_data_packet_monitor
- ipw_handle_promiscuous_rx
- is_network_packet
- is_duplicate_packet
- ipw_handle_mgmt_packet
- ipw_rx
- ipw_sw_reset
- ipw_set_channel
- ipw_wx_set_freq
- ipw_wx_get_freq
- ipw_wx_set_mode
- ipw_wx_get_mode
- ipw_wx_get_range
- ipw_wx_set_wap
- ipw_wx_get_wap
- ipw_wx_set_essid
- ipw_wx_get_essid
- ipw_wx_set_nick
- ipw_wx_get_nick
- ipw_wx_set_sens
- ipw_wx_get_sens
- ipw_wx_set_rate
- ipw_wx_get_rate
- ipw_wx_set_rts
- ipw_wx_get_rts
- ipw_wx_set_txpow
- ipw_wx_get_txpow
- ipw_wx_set_frag
- ipw_wx_get_frag
- ipw_wx_set_retry
- ipw_wx_get_retry
- ipw_wx_set_scan
- ipw_wx_get_scan
- ipw_wx_set_encode
- ipw_wx_get_encode
- ipw_wx_set_power
- ipw_wx_get_power
- ipw_wx_set_powermode
- ipw_wx_get_powermode
- ipw_wx_set_wireless_mode
- ipw_wx_get_wireless_mode
- ipw_wx_set_preamble
- ipw_wx_get_preamble
- ipw_wx_set_monitor
- ipw_wx_reset
- ipw_wx_sw_reset
- ipw_get_wireless_stats
- init_sys_config
- ipw_net_open
- ipw_net_stop
- ipw_tx_skb
- ipw_net_is_queue_full
- ipw_handle_promiscuous_tx
- ipw_net_hard_start_xmit
- ipw_net_set_multicast_list
- ipw_net_set_mac_address
- ipw_ethtool_get_drvinfo
- ipw_ethtool_get_link
- ipw_ethtool_get_eeprom_len
- ipw_ethtool_get_eeprom
- ipw_ethtool_set_eeprom
- ipw_isr
- ipw_rf_kill
- ipw_bg_rf_kill
- ipw_link_up
- ipw_bg_link_up
- ipw_link_down
- ipw_bg_link_down
- ipw_setup_deferred_work
- shim__set_security
- init_supported_rates
- ipw_config
- ipw_set_geo
- ipw_up
- ipw_bg_up
- ipw_deinit
- ipw_down
- ipw_bg_down
- ipw_wdev_init
- ipw_prom_open
- ipw_prom_stop
- ipw_prom_hard_start_xmit
- ipw_prom_alloc
- ipw_prom_free
- ipw_pci_probe
- ipw_pci_remove
- ipw_pci_suspend
- ipw_pci_resume
- ipw_pci_shutdown
- ipw_init
- ipw_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <net/cfg80211-wext.h>
22 #include "ipw2200.h"
23 #include "ipw.h"
24
25
26 #ifndef KBUILD_EXTMOD
27 #define VK "k"
28 #else
29 #define VK
30 #endif
31
32 #ifdef CONFIG_IPW2200_DEBUG
33 #define VD "d"
34 #else
35 #define VD
36 #endif
37
38 #ifdef CONFIG_IPW2200_MONITOR
39 #define VM "m"
40 #else
41 #define VM
42 #endif
43
44 #ifdef CONFIG_IPW2200_PROMISCUOUS
45 #define VP "p"
46 #else
47 #define VP
48 #endif
49
50 #ifdef CONFIG_IPW2200_RADIOTAP
51 #define VR "r"
52 #else
53 #define VR
54 #endif
55
56 #ifdef CONFIG_IPW2200_QOS
57 #define VQ "q"
58 #else
59 #define VQ
60 #endif
61
62 #define IPW2200_VERSION "1.2.2" VK VD VM VP VR VQ
63 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
64 #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
65 #define DRV_VERSION IPW2200_VERSION
66
67 #define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
68
69 MODULE_DESCRIPTION(DRV_DESCRIPTION);
70 MODULE_VERSION(DRV_VERSION);
71 MODULE_AUTHOR(DRV_COPYRIGHT);
72 MODULE_LICENSE("GPL");
73 MODULE_FIRMWARE("ipw2200-ibss.fw");
74 #ifdef CONFIG_IPW2200_MONITOR
75 MODULE_FIRMWARE("ipw2200-sniffer.fw");
76 #endif
77 MODULE_FIRMWARE("ipw2200-bss.fw");
78
79 static int cmdlog = 0;
80 static int debug = 0;
81 static int default_channel = 0;
82 static int network_mode = 0;
83
84 static u32 ipw_debug_level;
85 static int associate;
86 static int auto_create = 1;
87 static int led_support = 1;
88 static int disable = 0;
89 static int bt_coexist = 0;
90 static int hwcrypto = 0;
91 static int roaming = 1;
92 static const char ipw_modes[] = {
93 'a', 'b', 'g', '?'
94 };
95 static int antenna = CFG_SYS_ANTENNA_BOTH;
96
97 #ifdef CONFIG_IPW2200_PROMISCUOUS
98 static int rtap_iface = 0;
99 #endif
100
101 static struct ieee80211_rate ipw2200_rates[] = {
102 { .bitrate = 10 },
103 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
104 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
105 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
106 { .bitrate = 60 },
107 { .bitrate = 90 },
108 { .bitrate = 120 },
109 { .bitrate = 180 },
110 { .bitrate = 240 },
111 { .bitrate = 360 },
112 { .bitrate = 480 },
113 { .bitrate = 540 }
114 };
115
116 #define ipw2200_a_rates (ipw2200_rates + 4)
117 #define ipw2200_num_a_rates 8
118 #define ipw2200_bg_rates (ipw2200_rates + 0)
119 #define ipw2200_num_bg_rates 12
120
121
122
123
124 #define ieee80211chan2mhz(x) \
125 (((x) <= 14) ? \
126 (((x) == 14) ? 2484 : ((x) * 5) + 2407) : \
127 ((x) + 1000) * 5)
128
129 #ifdef CONFIG_IPW2200_QOS
130 static int qos_enable = 0;
131 static int qos_burst_enable = 0;
132 static int qos_no_ack_mask = 0;
133 static int burst_duration_CCK = 0;
134 static int burst_duration_OFDM = 0;
135
136 static struct libipw_qos_parameters def_qos_parameters_OFDM = {
137 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
138 QOS_TX3_CW_MIN_OFDM},
139 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
140 QOS_TX3_CW_MAX_OFDM},
141 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
142 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
143 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
144 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
145 };
146
147 static struct libipw_qos_parameters def_qos_parameters_CCK = {
148 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
149 QOS_TX3_CW_MIN_CCK},
150 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
151 QOS_TX3_CW_MAX_CCK},
152 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
153 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
154 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
155 QOS_TX3_TXOP_LIMIT_CCK}
156 };
157
158 static struct libipw_qos_parameters def_parameters_OFDM = {
159 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
160 DEF_TX3_CW_MIN_OFDM},
161 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
162 DEF_TX3_CW_MAX_OFDM},
163 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
164 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
165 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
166 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
167 };
168
169 static struct libipw_qos_parameters def_parameters_CCK = {
170 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
171 DEF_TX3_CW_MIN_CCK},
172 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
173 DEF_TX3_CW_MAX_CCK},
174 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
175 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
176 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
177 DEF_TX3_TXOP_LIMIT_CCK}
178 };
179
180 static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
181
182 static int from_priority_to_tx_queue[] = {
183 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
184 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
185 };
186
187 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
188
189 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
190 *qos_param);
191 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
192 *qos_param);
193 #endif
194
195 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
196 static void ipw_remove_current_network(struct ipw_priv *priv);
197 static void ipw_rx(struct ipw_priv *priv);
198 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
199 struct clx2_tx_queue *txq, int qindex);
200 static int ipw_queue_reset(struct ipw_priv *priv);
201
202 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
203 int len, int sync);
204
205 static void ipw_tx_queue_free(struct ipw_priv *);
206
207 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
208 static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
209 static void ipw_rx_queue_replenish(void *);
210 static int ipw_up(struct ipw_priv *);
211 static void ipw_bg_up(struct work_struct *work);
212 static void ipw_down(struct ipw_priv *);
213 static void ipw_bg_down(struct work_struct *work);
214 static int ipw_config(struct ipw_priv *);
215 static int init_supported_rates(struct ipw_priv *priv,
216 struct ipw_supported_rates *prates);
217 static void ipw_set_hwcrypto_keys(struct ipw_priv *);
218 static void ipw_send_wep_keys(struct ipw_priv *, int);
219
220 static int snprint_line(char *buf, size_t count,
221 const u8 * data, u32 len, u32 ofs)
222 {
223 int out, i, j, l;
224 char c;
225
226 out = snprintf(buf, count, "%08X", ofs);
227
228 for (l = 0, i = 0; i < 2; i++) {
229 out += snprintf(buf + out, count - out, " ");
230 for (j = 0; j < 8 && l < len; j++, l++)
231 out += snprintf(buf + out, count - out, "%02X ",
232 data[(i * 8 + j)]);
233 for (; j < 8; j++)
234 out += snprintf(buf + out, count - out, " ");
235 }
236
237 out += snprintf(buf + out, count - out, " ");
238 for (l = 0, i = 0; i < 2; i++) {
239 out += snprintf(buf + out, count - out, " ");
240 for (j = 0; j < 8 && l < len; j++, l++) {
241 c = data[(i * 8 + j)];
242 if (!isascii(c) || !isprint(c))
243 c = '.';
244
245 out += snprintf(buf + out, count - out, "%c", c);
246 }
247
248 for (; j < 8; j++)
249 out += snprintf(buf + out, count - out, " ");
250 }
251
252 return out;
253 }
254
255 static void printk_buf(int level, const u8 * data, u32 len)
256 {
257 char line[81];
258 u32 ofs = 0;
259 if (!(ipw_debug_level & level))
260 return;
261
262 while (len) {
263 snprint_line(line, sizeof(line), &data[ofs],
264 min(len, 16U), ofs);
265 printk(KERN_DEBUG "%s\n", line);
266 ofs += 16;
267 len -= min(len, 16U);
268 }
269 }
270
271 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
272 {
273 size_t out = size;
274 u32 ofs = 0;
275 int total = 0;
276
277 while (size && len) {
278 out = snprint_line(output, size, &data[ofs],
279 min_t(size_t, len, 16U), ofs);
280
281 ofs += 16;
282 output += out;
283 size -= out;
284 len -= min_t(size_t, len, 16U);
285 total += out;
286 }
287 return total;
288 }
289
290
291 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
292 #define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
293
294
295 static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
296 #define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
297
298
299 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
300 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
301 {
302 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
303 __LINE__, (u32) (b), (u32) (c));
304 _ipw_write_reg8(a, b, c);
305 }
306
307
308 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
309 static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
310 {
311 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
312 __LINE__, (u32) (b), (u32) (c));
313 _ipw_write_reg16(a, b, c);
314 }
315
316
317 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
318 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
319 {
320 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
321 __LINE__, (u32) (b), (u32) (c));
322 _ipw_write_reg32(a, b, c);
323 }
324
325
326 static inline void _ipw_write8(struct ipw_priv *ipw, unsigned long ofs,
327 u8 val)
328 {
329 writeb(val, ipw->hw_base + ofs);
330 }
331
332
333 #define ipw_write8(ipw, ofs, val) do { \
334 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, \
335 __LINE__, (u32)(ofs), (u32)(val)); \
336 _ipw_write8(ipw, ofs, val); \
337 } while (0)
338
339
340 static inline void _ipw_write16(struct ipw_priv *ipw, unsigned long ofs,
341 u16 val)
342 {
343 writew(val, ipw->hw_base + ofs);
344 }
345
346
347 #define ipw_write16(ipw, ofs, val) do { \
348 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, \
349 __LINE__, (u32)(ofs), (u32)(val)); \
350 _ipw_write16(ipw, ofs, val); \
351 } while (0)
352
353
354 static inline void _ipw_write32(struct ipw_priv *ipw, unsigned long ofs,
355 u32 val)
356 {
357 writel(val, ipw->hw_base + ofs);
358 }
359
360
361 #define ipw_write32(ipw, ofs, val) do { \
362 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, \
363 __LINE__, (u32)(ofs), (u32)(val)); \
364 _ipw_write32(ipw, ofs, val); \
365 } while (0)
366
367
368 static inline u8 _ipw_read8(struct ipw_priv *ipw, unsigned long ofs)
369 {
370 return readb(ipw->hw_base + ofs);
371 }
372
373
374 #define ipw_read8(ipw, ofs) ({ \
375 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", __FILE__, __LINE__, \
376 (u32)(ofs)); \
377 _ipw_read8(ipw, ofs); \
378 })
379
380
381 static inline u16 _ipw_read16(struct ipw_priv *ipw, unsigned long ofs)
382 {
383 return readw(ipw->hw_base + ofs);
384 }
385
386
387 #define ipw_read16(ipw, ofs) ({ \
388 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", __FILE__, __LINE__, \
389 (u32)(ofs)); \
390 _ipw_read16(ipw, ofs); \
391 })
392
393
394 static inline u32 _ipw_read32(struct ipw_priv *ipw, unsigned long ofs)
395 {
396 return readl(ipw->hw_base + ofs);
397 }
398
399
400 #define ipw_read32(ipw, ofs) ({ \
401 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", __FILE__, __LINE__, \
402 (u32)(ofs)); \
403 _ipw_read32(ipw, ofs); \
404 })
405
406 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
407
408 #define ipw_read_indirect(a, b, c, d) ({ \
409 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %u bytes\n", __FILE__, \
410 __LINE__, (u32)(b), (u32)(d)); \
411 _ipw_read_indirect(a, b, c, d); \
412 })
413
414
415 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
416 int num);
417 #define ipw_write_indirect(a, b, c, d) do { \
418 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %u bytes\n", __FILE__, \
419 __LINE__, (u32)(b), (u32)(d)); \
420 _ipw_write_indirect(a, b, c, d); \
421 } while (0)
422
423
424 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
425 {
426 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
427 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
428 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
429 }
430
431
432 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
433 {
434 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK;
435 u32 dif_len = reg - aligned_addr;
436
437 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
438 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
439 _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
440 }
441
442
443 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
444 {
445 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK;
446 u32 dif_len = (reg - aligned_addr) & (~0x1ul);
447
448 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
449 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
450 _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
451 }
452
453
454 static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
455 {
456 u32 word;
457 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
458 IPW_DEBUG_IO(" reg = 0x%8X :\n", reg);
459 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
460 return (word >> ((reg & 0x3) * 8)) & 0xff;
461 }
462
463
464 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
465 {
466 u32 value;
467
468 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
469
470 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
471 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
472 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x\n", reg, value);
473 return value;
474 }
475
476
477
478 static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
479 int num)
480 {
481 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
482 u32 dif_len = addr - aligned_addr;
483 u32 i;
484
485 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
486
487 if (num <= 0) {
488 return;
489 }
490
491
492 if (unlikely(dif_len)) {
493 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
494
495 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
496 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
497 aligned_addr += 4;
498 }
499
500
501 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
502 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
503 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
504
505
506 if (unlikely(num)) {
507 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
508 for (i = 0; num > 0; i++, num--)
509 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
510 }
511 }
512
513
514
515 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
516 int num)
517 {
518 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
519 u32 dif_len = addr - aligned_addr;
520 u32 i;
521
522 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
523
524 if (num <= 0) {
525 return;
526 }
527
528
529 if (unlikely(dif_len)) {
530 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
531
532 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
533 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
534 aligned_addr += 4;
535 }
536
537
538 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
539 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
540 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
541
542
543 if (unlikely(num)) {
544 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
545 for (i = 0; num > 0; i++, num--, buf++)
546 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
547 }
548 }
549
550
551
552 static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
553 int num)
554 {
555 memcpy_toio((priv->hw_base + addr), buf, num);
556 }
557
558
559 static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
560 {
561 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
562 }
563
564
565 static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
566 {
567 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
568 }
569
570 static inline void __ipw_enable_interrupts(struct ipw_priv *priv)
571 {
572 if (priv->status & STATUS_INT_ENABLED)
573 return;
574 priv->status |= STATUS_INT_ENABLED;
575 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
576 }
577
578 static inline void __ipw_disable_interrupts(struct ipw_priv *priv)
579 {
580 if (!(priv->status & STATUS_INT_ENABLED))
581 return;
582 priv->status &= ~STATUS_INT_ENABLED;
583 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
584 }
585
586 static inline void ipw_enable_interrupts(struct ipw_priv *priv)
587 {
588 unsigned long flags;
589
590 spin_lock_irqsave(&priv->irq_lock, flags);
591 __ipw_enable_interrupts(priv);
592 spin_unlock_irqrestore(&priv->irq_lock, flags);
593 }
594
595 static inline void ipw_disable_interrupts(struct ipw_priv *priv)
596 {
597 unsigned long flags;
598
599 spin_lock_irqsave(&priv->irq_lock, flags);
600 __ipw_disable_interrupts(priv);
601 spin_unlock_irqrestore(&priv->irq_lock, flags);
602 }
603
604 static char *ipw_error_desc(u32 val)
605 {
606 switch (val) {
607 case IPW_FW_ERROR_OK:
608 return "ERROR_OK";
609 case IPW_FW_ERROR_FAIL:
610 return "ERROR_FAIL";
611 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
612 return "MEMORY_UNDERFLOW";
613 case IPW_FW_ERROR_MEMORY_OVERFLOW:
614 return "MEMORY_OVERFLOW";
615 case IPW_FW_ERROR_BAD_PARAM:
616 return "BAD_PARAM";
617 case IPW_FW_ERROR_BAD_CHECKSUM:
618 return "BAD_CHECKSUM";
619 case IPW_FW_ERROR_NMI_INTERRUPT:
620 return "NMI_INTERRUPT";
621 case IPW_FW_ERROR_BAD_DATABASE:
622 return "BAD_DATABASE";
623 case IPW_FW_ERROR_ALLOC_FAIL:
624 return "ALLOC_FAIL";
625 case IPW_FW_ERROR_DMA_UNDERRUN:
626 return "DMA_UNDERRUN";
627 case IPW_FW_ERROR_DMA_STATUS:
628 return "DMA_STATUS";
629 case IPW_FW_ERROR_DINO_ERROR:
630 return "DINO_ERROR";
631 case IPW_FW_ERROR_EEPROM_ERROR:
632 return "EEPROM_ERROR";
633 case IPW_FW_ERROR_SYSASSERT:
634 return "SYSASSERT";
635 case IPW_FW_ERROR_FATAL_ERROR:
636 return "FATAL_ERROR";
637 default:
638 return "UNKNOWN_ERROR";
639 }
640 }
641
642 static void ipw_dump_error_log(struct ipw_priv *priv,
643 struct ipw_fw_error *error)
644 {
645 u32 i;
646
647 if (!error) {
648 IPW_ERROR("Error allocating and capturing error log. "
649 "Nothing to dump.\n");
650 return;
651 }
652
653 IPW_ERROR("Start IPW Error Log Dump:\n");
654 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
655 error->status, error->config);
656
657 for (i = 0; i < error->elem_len; i++)
658 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
659 ipw_error_desc(error->elem[i].desc),
660 error->elem[i].time,
661 error->elem[i].blink1,
662 error->elem[i].blink2,
663 error->elem[i].link1,
664 error->elem[i].link2, error->elem[i].data);
665 for (i = 0; i < error->log_len; i++)
666 IPW_ERROR("%i\t0x%08x\t%i\n",
667 error->log[i].time,
668 error->log[i].data, error->log[i].event);
669 }
670
671 static inline int ipw_is_init(struct ipw_priv *priv)
672 {
673 return (priv->status & STATUS_INIT) ? 1 : 0;
674 }
675
676 static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
677 {
678 u32 addr, field_info, field_len, field_count, total_len;
679
680 IPW_DEBUG_ORD("ordinal = %i\n", ord);
681
682 if (!priv || !val || !len) {
683 IPW_DEBUG_ORD("Invalid argument\n");
684 return -EINVAL;
685 }
686
687
688 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
689 IPW_DEBUG_ORD("Access ordinals before initialization\n");
690 return -EINVAL;
691 }
692
693 switch (IPW_ORD_TABLE_ID_MASK & ord) {
694 case IPW_ORD_TABLE_0_MASK:
695
696
697
698
699
700
701
702
703 ord &= IPW_ORD_TABLE_VALUE_MASK;
704
705
706 if (ord > priv->table0_len) {
707 IPW_DEBUG_ORD("ordinal value (%i) longer then "
708 "max (%i)\n", ord, priv->table0_len);
709 return -EINVAL;
710 }
711
712
713 if (*len < sizeof(u32)) {
714 IPW_DEBUG_ORD("ordinal buffer length too small, "
715 "need %zd\n", sizeof(u32));
716 return -EINVAL;
717 }
718
719 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
720 ord, priv->table0_addr + (ord << 2));
721
722 *len = sizeof(u32);
723 ord <<= 2;
724 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
725 break;
726
727 case IPW_ORD_TABLE_1_MASK:
728
729
730
731
732
733
734
735
736
737 ord &= IPW_ORD_TABLE_VALUE_MASK;
738
739
740 if (ord > priv->table1_len) {
741 IPW_DEBUG_ORD("ordinal value too long\n");
742 return -EINVAL;
743 }
744
745
746 if (*len < sizeof(u32)) {
747 IPW_DEBUG_ORD("ordinal buffer length too small, "
748 "need %zd\n", sizeof(u32));
749 return -EINVAL;
750 }
751
752 *((u32 *) val) =
753 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
754 *len = sizeof(u32);
755 break;
756
757 case IPW_ORD_TABLE_2_MASK:
758
759
760
761
762
763
764
765
766
767
768 ord &= IPW_ORD_TABLE_VALUE_MASK;
769
770
771 if (ord > priv->table2_len) {
772 IPW_DEBUG_ORD("ordinal value too long\n");
773 return -EINVAL;
774 }
775
776
777 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
778
779
780
781 field_info =
782 ipw_read_reg32(priv,
783 priv->table2_addr + (ord << 3) +
784 sizeof(u32));
785
786
787 field_len = *((u16 *) & field_info);
788
789
790 field_count = *(((u16 *) & field_info) + 1);
791
792
793 total_len = field_len * field_count;
794 if (total_len > *len) {
795 *len = total_len;
796 return -EINVAL;
797 }
798
799 *len = total_len;
800 if (!total_len)
801 return 0;
802
803 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
804 "field_info = 0x%08x\n",
805 addr, total_len, field_info);
806 ipw_read_indirect(priv, addr, val, total_len);
807 break;
808
809 default:
810 IPW_DEBUG_ORD("Invalid ordinal!\n");
811 return -EINVAL;
812
813 }
814
815 return 0;
816 }
817
818 static void ipw_init_ordinals(struct ipw_priv *priv)
819 {
820 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
821 priv->table0_len = ipw_read32(priv, priv->table0_addr);
822
823 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
824 priv->table0_addr, priv->table0_len);
825
826 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
827 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
828
829 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
830 priv->table1_addr, priv->table1_len);
831
832 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
833 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
834 priv->table2_len &= 0x0000ffff;
835
836 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
837 priv->table2_addr, priv->table2_len);
838
839 }
840
841 static u32 ipw_register_toggle(u32 reg)
842 {
843 reg &= ~IPW_START_STANDBY;
844 if (reg & IPW_GATE_ODMA)
845 reg &= ~IPW_GATE_ODMA;
846 if (reg & IPW_GATE_IDMA)
847 reg &= ~IPW_GATE_IDMA;
848 if (reg & IPW_GATE_ADMA)
849 reg &= ~IPW_GATE_ADMA;
850 return reg;
851 }
852
853
854
855
856
857
858
859
860
861
862 #define LD_TIME_LINK_ON msecs_to_jiffies(300)
863 #define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
864 #define LD_TIME_ACT_ON msecs_to_jiffies(250)
865
866 static void ipw_led_link_on(struct ipw_priv *priv)
867 {
868 unsigned long flags;
869 u32 led;
870
871
872
873 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
874 return;
875
876 spin_lock_irqsave(&priv->lock, flags);
877
878 if (!(priv->status & STATUS_RF_KILL_MASK) &&
879 !(priv->status & STATUS_LED_LINK_ON)) {
880 IPW_DEBUG_LED("Link LED On\n");
881 led = ipw_read_reg32(priv, IPW_EVENT_REG);
882 led |= priv->led_association_on;
883
884 led = ipw_register_toggle(led);
885
886 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
887 ipw_write_reg32(priv, IPW_EVENT_REG, led);
888
889 priv->status |= STATUS_LED_LINK_ON;
890
891
892 if (!(priv->status & STATUS_ASSOCIATED))
893 schedule_delayed_work(&priv->led_link_off,
894 LD_TIME_LINK_ON);
895 }
896
897 spin_unlock_irqrestore(&priv->lock, flags);
898 }
899
900 static void ipw_bg_led_link_on(struct work_struct *work)
901 {
902 struct ipw_priv *priv =
903 container_of(work, struct ipw_priv, led_link_on.work);
904 mutex_lock(&priv->mutex);
905 ipw_led_link_on(priv);
906 mutex_unlock(&priv->mutex);
907 }
908
909 static void ipw_led_link_off(struct ipw_priv *priv)
910 {
911 unsigned long flags;
912 u32 led;
913
914
915
916 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
917 return;
918
919 spin_lock_irqsave(&priv->lock, flags);
920
921 if (priv->status & STATUS_LED_LINK_ON) {
922 led = ipw_read_reg32(priv, IPW_EVENT_REG);
923 led &= priv->led_association_off;
924 led = ipw_register_toggle(led);
925
926 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
927 ipw_write_reg32(priv, IPW_EVENT_REG, led);
928
929 IPW_DEBUG_LED("Link LED Off\n");
930
931 priv->status &= ~STATUS_LED_LINK_ON;
932
933
934
935 if (!(priv->status & STATUS_RF_KILL_MASK) &&
936 !(priv->status & STATUS_ASSOCIATED))
937 schedule_delayed_work(&priv->led_link_on,
938 LD_TIME_LINK_OFF);
939
940 }
941
942 spin_unlock_irqrestore(&priv->lock, flags);
943 }
944
945 static void ipw_bg_led_link_off(struct work_struct *work)
946 {
947 struct ipw_priv *priv =
948 container_of(work, struct ipw_priv, led_link_off.work);
949 mutex_lock(&priv->mutex);
950 ipw_led_link_off(priv);
951 mutex_unlock(&priv->mutex);
952 }
953
954 static void __ipw_led_activity_on(struct ipw_priv *priv)
955 {
956 u32 led;
957
958 if (priv->config & CFG_NO_LED)
959 return;
960
961 if (priv->status & STATUS_RF_KILL_MASK)
962 return;
963
964 if (!(priv->status & STATUS_LED_ACT_ON)) {
965 led = ipw_read_reg32(priv, IPW_EVENT_REG);
966 led |= priv->led_activity_on;
967
968 led = ipw_register_toggle(led);
969
970 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
971 ipw_write_reg32(priv, IPW_EVENT_REG, led);
972
973 IPW_DEBUG_LED("Activity LED On\n");
974
975 priv->status |= STATUS_LED_ACT_ON;
976
977 cancel_delayed_work(&priv->led_act_off);
978 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
979 } else {
980
981 cancel_delayed_work(&priv->led_act_off);
982 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
983 }
984 }
985
986 #if 0
987 void ipw_led_activity_on(struct ipw_priv *priv)
988 {
989 unsigned long flags;
990 spin_lock_irqsave(&priv->lock, flags);
991 __ipw_led_activity_on(priv);
992 spin_unlock_irqrestore(&priv->lock, flags);
993 }
994 #endif
995
996 static void ipw_led_activity_off(struct ipw_priv *priv)
997 {
998 unsigned long flags;
999 u32 led;
1000
1001 if (priv->config & CFG_NO_LED)
1002 return;
1003
1004 spin_lock_irqsave(&priv->lock, flags);
1005
1006 if (priv->status & STATUS_LED_ACT_ON) {
1007 led = ipw_read_reg32(priv, IPW_EVENT_REG);
1008 led &= priv->led_activity_off;
1009
1010 led = ipw_register_toggle(led);
1011
1012 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1013 ipw_write_reg32(priv, IPW_EVENT_REG, led);
1014
1015 IPW_DEBUG_LED("Activity LED Off\n");
1016
1017 priv->status &= ~STATUS_LED_ACT_ON;
1018 }
1019
1020 spin_unlock_irqrestore(&priv->lock, flags);
1021 }
1022
1023 static void ipw_bg_led_activity_off(struct work_struct *work)
1024 {
1025 struct ipw_priv *priv =
1026 container_of(work, struct ipw_priv, led_act_off.work);
1027 mutex_lock(&priv->mutex);
1028 ipw_led_activity_off(priv);
1029 mutex_unlock(&priv->mutex);
1030 }
1031
1032 static void ipw_led_band_on(struct ipw_priv *priv)
1033 {
1034 unsigned long flags;
1035 u32 led;
1036
1037
1038 if (priv->config & CFG_NO_LED ||
1039 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
1040 return;
1041
1042 spin_lock_irqsave(&priv->lock, flags);
1043
1044 led = ipw_read_reg32(priv, IPW_EVENT_REG);
1045 if (priv->assoc_network->mode == IEEE_A) {
1046 led |= priv->led_ofdm_on;
1047 led &= priv->led_association_off;
1048 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
1049 } else if (priv->assoc_network->mode == IEEE_G) {
1050 led |= priv->led_ofdm_on;
1051 led |= priv->led_association_on;
1052 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
1053 } else {
1054 led &= priv->led_ofdm_off;
1055 led |= priv->led_association_on;
1056 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
1057 }
1058
1059 led = ipw_register_toggle(led);
1060
1061 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1062 ipw_write_reg32(priv, IPW_EVENT_REG, led);
1063
1064 spin_unlock_irqrestore(&priv->lock, flags);
1065 }
1066
1067 static void ipw_led_band_off(struct ipw_priv *priv)
1068 {
1069 unsigned long flags;
1070 u32 led;
1071
1072
1073 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
1074 return;
1075
1076 spin_lock_irqsave(&priv->lock, flags);
1077
1078 led = ipw_read_reg32(priv, IPW_EVENT_REG);
1079 led &= priv->led_ofdm_off;
1080 led &= priv->led_association_off;
1081
1082 led = ipw_register_toggle(led);
1083
1084 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1085 ipw_write_reg32(priv, IPW_EVENT_REG, led);
1086
1087 spin_unlock_irqrestore(&priv->lock, flags);
1088 }
1089
1090 static void ipw_led_radio_on(struct ipw_priv *priv)
1091 {
1092 ipw_led_link_on(priv);
1093 }
1094
1095 static void ipw_led_radio_off(struct ipw_priv *priv)
1096 {
1097 ipw_led_activity_off(priv);
1098 ipw_led_link_off(priv);
1099 }
1100
1101 static void ipw_led_link_up(struct ipw_priv *priv)
1102 {
1103
1104 ipw_led_link_on(priv);
1105 }
1106
1107 static void ipw_led_link_down(struct ipw_priv *priv)
1108 {
1109 ipw_led_activity_off(priv);
1110 ipw_led_link_off(priv);
1111
1112 if (priv->status & STATUS_RF_KILL_MASK)
1113 ipw_led_radio_off(priv);
1114 }
1115
1116 static void ipw_led_init(struct ipw_priv *priv)
1117 {
1118 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1119
1120
1121 priv->led_activity_on = IPW_ACTIVITY_LED;
1122 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
1123
1124 priv->led_association_on = IPW_ASSOCIATED_LED;
1125 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
1126
1127
1128 priv->led_ofdm_on = IPW_OFDM_LED;
1129 priv->led_ofdm_off = ~(IPW_OFDM_LED);
1130
1131 switch (priv->nic_type) {
1132 case EEPROM_NIC_TYPE_1:
1133
1134 priv->led_activity_on = IPW_ASSOCIATED_LED;
1135 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1136 priv->led_association_on = IPW_ACTIVITY_LED;
1137 priv->led_association_off = ~(IPW_ACTIVITY_LED);
1138
1139 if (!(priv->config & CFG_NO_LED))
1140 ipw_led_band_on(priv);
1141
1142
1143
1144 return;
1145
1146 case EEPROM_NIC_TYPE_3:
1147 case EEPROM_NIC_TYPE_2:
1148 case EEPROM_NIC_TYPE_4:
1149 case EEPROM_NIC_TYPE_0:
1150 break;
1151
1152 default:
1153 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1154 priv->nic_type);
1155 priv->nic_type = EEPROM_NIC_TYPE_0;
1156 break;
1157 }
1158
1159 if (!(priv->config & CFG_NO_LED)) {
1160 if (priv->status & STATUS_ASSOCIATED)
1161 ipw_led_link_on(priv);
1162 else
1163 ipw_led_link_off(priv);
1164 }
1165 }
1166
1167 static void ipw_led_shutdown(struct ipw_priv *priv)
1168 {
1169 ipw_led_activity_off(priv);
1170 ipw_led_link_off(priv);
1171 ipw_led_band_off(priv);
1172 cancel_delayed_work(&priv->led_link_on);
1173 cancel_delayed_work(&priv->led_link_off);
1174 cancel_delayed_work(&priv->led_act_off);
1175 }
1176
1177
1178
1179
1180
1181
1182
1183
1184 static ssize_t debug_level_show(struct device_driver *d, char *buf)
1185 {
1186 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1187 }
1188
1189 static ssize_t debug_level_store(struct device_driver *d, const char *buf,
1190 size_t count)
1191 {
1192 char *p = (char *)buf;
1193 u32 val;
1194
1195 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1196 p++;
1197 if (p[0] == 'x' || p[0] == 'X')
1198 p++;
1199 val = simple_strtoul(p, &p, 16);
1200 } else
1201 val = simple_strtoul(p, &p, 10);
1202 if (p == buf)
1203 printk(KERN_INFO DRV_NAME
1204 ": %s is not in hex or decimal form.\n", buf);
1205 else
1206 ipw_debug_level = val;
1207
1208 return strnlen(buf, count);
1209 }
1210 static DRIVER_ATTR_RW(debug_level);
1211
1212 static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1213 {
1214
1215 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1216 }
1217
1218 static void ipw_capture_event_log(struct ipw_priv *priv,
1219 u32 log_len, struct ipw_event *log)
1220 {
1221 u32 base;
1222
1223 if (log_len) {
1224 base = ipw_read32(priv, IPW_EVENT_LOG);
1225 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1226 (u8 *) log, sizeof(*log) * log_len);
1227 }
1228 }
1229
1230 static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1231 {
1232 struct ipw_fw_error *error;
1233 u32 log_len = ipw_get_event_log_len(priv);
1234 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1235 u32 elem_len = ipw_read_reg32(priv, base);
1236
1237 error = kmalloc(sizeof(*error) +
1238 sizeof(*error->elem) * elem_len +
1239 sizeof(*error->log) * log_len, GFP_ATOMIC);
1240 if (!error) {
1241 IPW_ERROR("Memory allocation for firmware error log "
1242 "failed.\n");
1243 return NULL;
1244 }
1245 error->jiffies = jiffies;
1246 error->status = priv->status;
1247 error->config = priv->config;
1248 error->elem_len = elem_len;
1249 error->log_len = log_len;
1250 error->elem = (struct ipw_error_elem *)error->payload;
1251 error->log = (struct ipw_event *)(error->elem + elem_len);
1252
1253 ipw_capture_event_log(priv, log_len, error->log);
1254
1255 if (elem_len)
1256 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1257 sizeof(*error->elem) * elem_len);
1258
1259 return error;
1260 }
1261
1262 static ssize_t show_event_log(struct device *d,
1263 struct device_attribute *attr, char *buf)
1264 {
1265 struct ipw_priv *priv = dev_get_drvdata(d);
1266 u32 log_len = ipw_get_event_log_len(priv);
1267 u32 log_size;
1268 struct ipw_event *log;
1269 u32 len = 0, i;
1270
1271
1272 log_size = PAGE_SIZE / sizeof(*log) > log_len ?
1273 sizeof(*log) * log_len : PAGE_SIZE;
1274 log = kzalloc(log_size, GFP_KERNEL);
1275 if (!log) {
1276 IPW_ERROR("Unable to allocate memory for log\n");
1277 return 0;
1278 }
1279 log_len = log_size / sizeof(*log);
1280 ipw_capture_event_log(priv, log_len, log);
1281
1282 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1283 for (i = 0; i < log_len; i++)
1284 len += snprintf(buf + len, PAGE_SIZE - len,
1285 "\n%08X%08X%08X",
1286 log[i].time, log[i].event, log[i].data);
1287 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1288 kfree(log);
1289 return len;
1290 }
1291
1292 static DEVICE_ATTR(event_log, 0444, show_event_log, NULL);
1293
1294 static ssize_t show_error(struct device *d,
1295 struct device_attribute *attr, char *buf)
1296 {
1297 struct ipw_priv *priv = dev_get_drvdata(d);
1298 u32 len = 0, i;
1299 if (!priv->error)
1300 return 0;
1301 len += snprintf(buf + len, PAGE_SIZE - len,
1302 "%08lX%08X%08X%08X",
1303 priv->error->jiffies,
1304 priv->error->status,
1305 priv->error->config, priv->error->elem_len);
1306 for (i = 0; i < priv->error->elem_len; i++)
1307 len += snprintf(buf + len, PAGE_SIZE - len,
1308 "\n%08X%08X%08X%08X%08X%08X%08X",
1309 priv->error->elem[i].time,
1310 priv->error->elem[i].desc,
1311 priv->error->elem[i].blink1,
1312 priv->error->elem[i].blink2,
1313 priv->error->elem[i].link1,
1314 priv->error->elem[i].link2,
1315 priv->error->elem[i].data);
1316
1317 len += snprintf(buf + len, PAGE_SIZE - len,
1318 "\n%08X", priv->error->log_len);
1319 for (i = 0; i < priv->error->log_len; i++)
1320 len += snprintf(buf + len, PAGE_SIZE - len,
1321 "\n%08X%08X%08X",
1322 priv->error->log[i].time,
1323 priv->error->log[i].event,
1324 priv->error->log[i].data);
1325 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1326 return len;
1327 }
1328
1329 static ssize_t clear_error(struct device *d,
1330 struct device_attribute *attr,
1331 const char *buf, size_t count)
1332 {
1333 struct ipw_priv *priv = dev_get_drvdata(d);
1334
1335 kfree(priv->error);
1336 priv->error = NULL;
1337 return count;
1338 }
1339
1340 static DEVICE_ATTR(error, 0644, show_error, clear_error);
1341
1342 static ssize_t show_cmd_log(struct device *d,
1343 struct device_attribute *attr, char *buf)
1344 {
1345 struct ipw_priv *priv = dev_get_drvdata(d);
1346 u32 len = 0, i;
1347 if (!priv->cmdlog)
1348 return 0;
1349 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1350 (i != priv->cmdlog_pos) && (len < PAGE_SIZE);
1351 i = (i + 1) % priv->cmdlog_len) {
1352 len +=
1353 snprintf(buf + len, PAGE_SIZE - len,
1354 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1355 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1356 priv->cmdlog[i].cmd.len);
1357 len +=
1358 snprintk_buf(buf + len, PAGE_SIZE - len,
1359 (u8 *) priv->cmdlog[i].cmd.param,
1360 priv->cmdlog[i].cmd.len);
1361 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1362 }
1363 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1364 return len;
1365 }
1366
1367 static DEVICE_ATTR(cmd_log, 0444, show_cmd_log, NULL);
1368
1369 #ifdef CONFIG_IPW2200_PROMISCUOUS
1370 static void ipw_prom_free(struct ipw_priv *priv);
1371 static int ipw_prom_alloc(struct ipw_priv *priv);
1372 static ssize_t store_rtap_iface(struct device *d,
1373 struct device_attribute *attr,
1374 const char *buf, size_t count)
1375 {
1376 struct ipw_priv *priv = dev_get_drvdata(d);
1377 int rc = 0;
1378
1379 if (count < 1)
1380 return -EINVAL;
1381
1382 switch (buf[0]) {
1383 case '0':
1384 if (!rtap_iface)
1385 return count;
1386
1387 if (netif_running(priv->prom_net_dev)) {
1388 IPW_WARNING("Interface is up. Cannot unregister.\n");
1389 return count;
1390 }
1391
1392 ipw_prom_free(priv);
1393 rtap_iface = 0;
1394 break;
1395
1396 case '1':
1397 if (rtap_iface)
1398 return count;
1399
1400 rc = ipw_prom_alloc(priv);
1401 if (!rc)
1402 rtap_iface = 1;
1403 break;
1404
1405 default:
1406 return -EINVAL;
1407 }
1408
1409 if (rc) {
1410 IPW_ERROR("Failed to register promiscuous network "
1411 "device (error %d).\n", rc);
1412 }
1413
1414 return count;
1415 }
1416
1417 static ssize_t show_rtap_iface(struct device *d,
1418 struct device_attribute *attr,
1419 char *buf)
1420 {
1421 struct ipw_priv *priv = dev_get_drvdata(d);
1422 if (rtap_iface)
1423 return sprintf(buf, "%s", priv->prom_net_dev->name);
1424 else {
1425 buf[0] = '-';
1426 buf[1] = '1';
1427 buf[2] = '\0';
1428 return 3;
1429 }
1430 }
1431
1432 static DEVICE_ATTR(rtap_iface, 0600, show_rtap_iface, store_rtap_iface);
1433
1434 static ssize_t store_rtap_filter(struct device *d,
1435 struct device_attribute *attr,
1436 const char *buf, size_t count)
1437 {
1438 struct ipw_priv *priv = dev_get_drvdata(d);
1439
1440 if (!priv->prom_priv) {
1441 IPW_ERROR("Attempting to set filter without "
1442 "rtap_iface enabled.\n");
1443 return -EPERM;
1444 }
1445
1446 priv->prom_priv->filter = simple_strtol(buf, NULL, 0);
1447
1448 IPW_DEBUG_INFO("Setting rtap filter to " BIT_FMT16 "\n",
1449 BIT_ARG16(priv->prom_priv->filter));
1450
1451 return count;
1452 }
1453
1454 static ssize_t show_rtap_filter(struct device *d,
1455 struct device_attribute *attr,
1456 char *buf)
1457 {
1458 struct ipw_priv *priv = dev_get_drvdata(d);
1459 return sprintf(buf, "0x%04X",
1460 priv->prom_priv ? priv->prom_priv->filter : 0);
1461 }
1462
1463 static DEVICE_ATTR(rtap_filter, 0600, show_rtap_filter, store_rtap_filter);
1464 #endif
1465
1466 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1467 char *buf)
1468 {
1469 struct ipw_priv *priv = dev_get_drvdata(d);
1470 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1471 }
1472
1473 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1474 const char *buf, size_t count)
1475 {
1476 struct ipw_priv *priv = dev_get_drvdata(d);
1477 struct net_device *dev = priv->net_dev;
1478 char buffer[] = "00000000";
1479 unsigned long len =
1480 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1481 unsigned long val;
1482 char *p = buffer;
1483
1484 IPW_DEBUG_INFO("enter\n");
1485
1486 strncpy(buffer, buf, len);
1487 buffer[len] = 0;
1488
1489 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1490 p++;
1491 if (p[0] == 'x' || p[0] == 'X')
1492 p++;
1493 val = simple_strtoul(p, &p, 16);
1494 } else
1495 val = simple_strtoul(p, &p, 10);
1496 if (p == buffer) {
1497 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1498 } else {
1499 priv->ieee->scan_age = val;
1500 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1501 }
1502
1503 IPW_DEBUG_INFO("exit\n");
1504 return len;
1505 }
1506
1507 static DEVICE_ATTR(scan_age, 0644, show_scan_age, store_scan_age);
1508
1509 static ssize_t show_led(struct device *d, struct device_attribute *attr,
1510 char *buf)
1511 {
1512 struct ipw_priv *priv = dev_get_drvdata(d);
1513 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1514 }
1515
1516 static ssize_t store_led(struct device *d, struct device_attribute *attr,
1517 const char *buf, size_t count)
1518 {
1519 struct ipw_priv *priv = dev_get_drvdata(d);
1520
1521 IPW_DEBUG_INFO("enter\n");
1522
1523 if (count == 0)
1524 return 0;
1525
1526 if (*buf == 0) {
1527 IPW_DEBUG_LED("Disabling LED control.\n");
1528 priv->config |= CFG_NO_LED;
1529 ipw_led_shutdown(priv);
1530 } else {
1531 IPW_DEBUG_LED("Enabling LED control.\n");
1532 priv->config &= ~CFG_NO_LED;
1533 ipw_led_init(priv);
1534 }
1535
1536 IPW_DEBUG_INFO("exit\n");
1537 return count;
1538 }
1539
1540 static DEVICE_ATTR(led, 0644, show_led, store_led);
1541
1542 static ssize_t show_status(struct device *d,
1543 struct device_attribute *attr, char *buf)
1544 {
1545 struct ipw_priv *p = dev_get_drvdata(d);
1546 return sprintf(buf, "0x%08x\n", (int)p->status);
1547 }
1548
1549 static DEVICE_ATTR(status, 0444, show_status, NULL);
1550
1551 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1552 char *buf)
1553 {
1554 struct ipw_priv *p = dev_get_drvdata(d);
1555 return sprintf(buf, "0x%08x\n", (int)p->config);
1556 }
1557
1558 static DEVICE_ATTR(cfg, 0444, show_cfg, NULL);
1559
1560 static ssize_t show_nic_type(struct device *d,
1561 struct device_attribute *attr, char *buf)
1562 {
1563 struct ipw_priv *priv = dev_get_drvdata(d);
1564 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1565 }
1566
1567 static DEVICE_ATTR(nic_type, 0444, show_nic_type, NULL);
1568
1569 static ssize_t show_ucode_version(struct device *d,
1570 struct device_attribute *attr, char *buf)
1571 {
1572 u32 len = sizeof(u32), tmp = 0;
1573 struct ipw_priv *p = dev_get_drvdata(d);
1574
1575 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1576 return 0;
1577
1578 return sprintf(buf, "0x%08x\n", tmp);
1579 }
1580
1581 static DEVICE_ATTR(ucode_version, 0644, show_ucode_version, NULL);
1582
1583 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1584 char *buf)
1585 {
1586 u32 len = sizeof(u32), tmp = 0;
1587 struct ipw_priv *p = dev_get_drvdata(d);
1588
1589 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1590 return 0;
1591
1592 return sprintf(buf, "0x%08x\n", tmp);
1593 }
1594
1595 static DEVICE_ATTR(rtc, 0644, show_rtc, NULL);
1596
1597
1598
1599
1600
1601 static ssize_t show_eeprom_delay(struct device *d,
1602 struct device_attribute *attr, char *buf)
1603 {
1604 struct ipw_priv *p = dev_get_drvdata(d);
1605 int n = p->eeprom_delay;
1606 return sprintf(buf, "%i\n", n);
1607 }
1608 static ssize_t store_eeprom_delay(struct device *d,
1609 struct device_attribute *attr,
1610 const char *buf, size_t count)
1611 {
1612 struct ipw_priv *p = dev_get_drvdata(d);
1613 sscanf(buf, "%i", &p->eeprom_delay);
1614 return strnlen(buf, count);
1615 }
1616
1617 static DEVICE_ATTR(eeprom_delay, 0644, show_eeprom_delay, store_eeprom_delay);
1618
1619 static ssize_t show_command_event_reg(struct device *d,
1620 struct device_attribute *attr, char *buf)
1621 {
1622 u32 reg = 0;
1623 struct ipw_priv *p = dev_get_drvdata(d);
1624
1625 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1626 return sprintf(buf, "0x%08x\n", reg);
1627 }
1628 static ssize_t store_command_event_reg(struct device *d,
1629 struct device_attribute *attr,
1630 const char *buf, size_t count)
1631 {
1632 u32 reg;
1633 struct ipw_priv *p = dev_get_drvdata(d);
1634
1635 sscanf(buf, "%x", ®);
1636 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1637 return strnlen(buf, count);
1638 }
1639
1640 static DEVICE_ATTR(command_event_reg, 0644,
1641 show_command_event_reg, store_command_event_reg);
1642
1643 static ssize_t show_mem_gpio_reg(struct device *d,
1644 struct device_attribute *attr, char *buf)
1645 {
1646 u32 reg = 0;
1647 struct ipw_priv *p = dev_get_drvdata(d);
1648
1649 reg = ipw_read_reg32(p, 0x301100);
1650 return sprintf(buf, "0x%08x\n", reg);
1651 }
1652 static ssize_t store_mem_gpio_reg(struct device *d,
1653 struct device_attribute *attr,
1654 const char *buf, size_t count)
1655 {
1656 u32 reg;
1657 struct ipw_priv *p = dev_get_drvdata(d);
1658
1659 sscanf(buf, "%x", ®);
1660 ipw_write_reg32(p, 0x301100, reg);
1661 return strnlen(buf, count);
1662 }
1663
1664 static DEVICE_ATTR(mem_gpio_reg, 0644, show_mem_gpio_reg, store_mem_gpio_reg);
1665
1666 static ssize_t show_indirect_dword(struct device *d,
1667 struct device_attribute *attr, char *buf)
1668 {
1669 u32 reg = 0;
1670 struct ipw_priv *priv = dev_get_drvdata(d);
1671
1672 if (priv->status & STATUS_INDIRECT_DWORD)
1673 reg = ipw_read_reg32(priv, priv->indirect_dword);
1674 else
1675 reg = 0;
1676
1677 return sprintf(buf, "0x%08x\n", reg);
1678 }
1679 static ssize_t store_indirect_dword(struct device *d,
1680 struct device_attribute *attr,
1681 const char *buf, size_t count)
1682 {
1683 struct ipw_priv *priv = dev_get_drvdata(d);
1684
1685 sscanf(buf, "%x", &priv->indirect_dword);
1686 priv->status |= STATUS_INDIRECT_DWORD;
1687 return strnlen(buf, count);
1688 }
1689
1690 static DEVICE_ATTR(indirect_dword, 0644,
1691 show_indirect_dword, store_indirect_dword);
1692
1693 static ssize_t show_indirect_byte(struct device *d,
1694 struct device_attribute *attr, char *buf)
1695 {
1696 u8 reg = 0;
1697 struct ipw_priv *priv = dev_get_drvdata(d);
1698
1699 if (priv->status & STATUS_INDIRECT_BYTE)
1700 reg = ipw_read_reg8(priv, priv->indirect_byte);
1701 else
1702 reg = 0;
1703
1704 return sprintf(buf, "0x%02x\n", reg);
1705 }
1706 static ssize_t store_indirect_byte(struct device *d,
1707 struct device_attribute *attr,
1708 const char *buf, size_t count)
1709 {
1710 struct ipw_priv *priv = dev_get_drvdata(d);
1711
1712 sscanf(buf, "%x", &priv->indirect_byte);
1713 priv->status |= STATUS_INDIRECT_BYTE;
1714 return strnlen(buf, count);
1715 }
1716
1717 static DEVICE_ATTR(indirect_byte, 0644,
1718 show_indirect_byte, store_indirect_byte);
1719
1720 static ssize_t show_direct_dword(struct device *d,
1721 struct device_attribute *attr, char *buf)
1722 {
1723 u32 reg = 0;
1724 struct ipw_priv *priv = dev_get_drvdata(d);
1725
1726 if (priv->status & STATUS_DIRECT_DWORD)
1727 reg = ipw_read32(priv, priv->direct_dword);
1728 else
1729 reg = 0;
1730
1731 return sprintf(buf, "0x%08x\n", reg);
1732 }
1733 static ssize_t store_direct_dword(struct device *d,
1734 struct device_attribute *attr,
1735 const char *buf, size_t count)
1736 {
1737 struct ipw_priv *priv = dev_get_drvdata(d);
1738
1739 sscanf(buf, "%x", &priv->direct_dword);
1740 priv->status |= STATUS_DIRECT_DWORD;
1741 return strnlen(buf, count);
1742 }
1743
1744 static DEVICE_ATTR(direct_dword, 0644, show_direct_dword, store_direct_dword);
1745
1746 static int rf_kill_active(struct ipw_priv *priv)
1747 {
1748 if (0 == (ipw_read32(priv, 0x30) & 0x10000)) {
1749 priv->status |= STATUS_RF_KILL_HW;
1750 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1751 } else {
1752 priv->status &= ~STATUS_RF_KILL_HW;
1753 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1754 }
1755
1756 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1757 }
1758
1759 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1760 char *buf)
1761 {
1762
1763
1764
1765
1766 struct ipw_priv *priv = dev_get_drvdata(d);
1767 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1768 (rf_kill_active(priv) ? 0x2 : 0x0);
1769 return sprintf(buf, "%i\n", val);
1770 }
1771
1772 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1773 {
1774 if ((disable_radio ? 1 : 0) ==
1775 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1776 return 0;
1777
1778 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1779 disable_radio ? "OFF" : "ON");
1780
1781 if (disable_radio) {
1782 priv->status |= STATUS_RF_KILL_SW;
1783
1784 cancel_delayed_work(&priv->request_scan);
1785 cancel_delayed_work(&priv->request_direct_scan);
1786 cancel_delayed_work(&priv->request_passive_scan);
1787 cancel_delayed_work(&priv->scan_event);
1788 schedule_work(&priv->down);
1789 } else {
1790 priv->status &= ~STATUS_RF_KILL_SW;
1791 if (rf_kill_active(priv)) {
1792 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1793 "disabled by HW switch\n");
1794
1795 cancel_delayed_work(&priv->rf_kill);
1796 schedule_delayed_work(&priv->rf_kill,
1797 round_jiffies_relative(2 * HZ));
1798 } else
1799 schedule_work(&priv->up);
1800 }
1801
1802 return 1;
1803 }
1804
1805 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1806 const char *buf, size_t count)
1807 {
1808 struct ipw_priv *priv = dev_get_drvdata(d);
1809
1810 ipw_radio_kill_sw(priv, buf[0] == '1');
1811
1812 return count;
1813 }
1814
1815 static DEVICE_ATTR(rf_kill, 0644, show_rf_kill, store_rf_kill);
1816
1817 static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1818 char *buf)
1819 {
1820 struct ipw_priv *priv = dev_get_drvdata(d);
1821 int pos = 0, len = 0;
1822 if (priv->config & CFG_SPEED_SCAN) {
1823 while (priv->speed_scan[pos] != 0)
1824 len += sprintf(&buf[len], "%d ",
1825 priv->speed_scan[pos++]);
1826 return len + sprintf(&buf[len], "\n");
1827 }
1828
1829 return sprintf(buf, "0\n");
1830 }
1831
1832 static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1833 const char *buf, size_t count)
1834 {
1835 struct ipw_priv *priv = dev_get_drvdata(d);
1836 int channel, pos = 0;
1837 const char *p = buf;
1838
1839
1840 while ((channel = simple_strtol(p, NULL, 0))) {
1841 if (pos == MAX_SPEED_SCAN - 1) {
1842 priv->speed_scan[pos] = 0;
1843 break;
1844 }
1845
1846 if (libipw_is_valid_channel(priv->ieee, channel))
1847 priv->speed_scan[pos++] = channel;
1848 else
1849 IPW_WARNING("Skipping invalid channel request: %d\n",
1850 channel);
1851 p = strchr(p, ' ');
1852 if (!p)
1853 break;
1854 while (*p == ' ' || *p == '\t')
1855 p++;
1856 }
1857
1858 if (pos == 0)
1859 priv->config &= ~CFG_SPEED_SCAN;
1860 else {
1861 priv->speed_scan_pos = 0;
1862 priv->config |= CFG_SPEED_SCAN;
1863 }
1864
1865 return count;
1866 }
1867
1868 static DEVICE_ATTR(speed_scan, 0644, show_speed_scan, store_speed_scan);
1869
1870 static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1871 char *buf)
1872 {
1873 struct ipw_priv *priv = dev_get_drvdata(d);
1874 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1875 }
1876
1877 static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1878 const char *buf, size_t count)
1879 {
1880 struct ipw_priv *priv = dev_get_drvdata(d);
1881 if (buf[0] == '1')
1882 priv->config |= CFG_NET_STATS;
1883 else
1884 priv->config &= ~CFG_NET_STATS;
1885
1886 return count;
1887 }
1888
1889 static DEVICE_ATTR(net_stats, 0644, show_net_stats, store_net_stats);
1890
1891 static ssize_t show_channels(struct device *d,
1892 struct device_attribute *attr,
1893 char *buf)
1894 {
1895 struct ipw_priv *priv = dev_get_drvdata(d);
1896 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
1897 int len = 0, i;
1898
1899 len = sprintf(&buf[len],
1900 "Displaying %d channels in 2.4Ghz band "
1901 "(802.11bg):\n", geo->bg_channels);
1902
1903 for (i = 0; i < geo->bg_channels; i++) {
1904 len += sprintf(&buf[len], "%d: BSS%s%s, %s, Band %s.\n",
1905 geo->bg[i].channel,
1906 geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT ?
1907 " (radar spectrum)" : "",
1908 ((geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ||
1909 (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT))
1910 ? "" : ", IBSS",
1911 geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1912 "passive only" : "active/passive",
1913 geo->bg[i].flags & LIBIPW_CH_B_ONLY ?
1914 "B" : "B/G");
1915 }
1916
1917 len += sprintf(&buf[len],
1918 "Displaying %d channels in 5.2Ghz band "
1919 "(802.11a):\n", geo->a_channels);
1920 for (i = 0; i < geo->a_channels; i++) {
1921 len += sprintf(&buf[len], "%d: BSS%s%s, %s.\n",
1922 geo->a[i].channel,
1923 geo->a[i].flags & LIBIPW_CH_RADAR_DETECT ?
1924 " (radar spectrum)" : "",
1925 ((geo->a[i].flags & LIBIPW_CH_NO_IBSS) ||
1926 (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT))
1927 ? "" : ", IBSS",
1928 geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1929 "passive only" : "active/passive");
1930 }
1931
1932 return len;
1933 }
1934
1935 static DEVICE_ATTR(channels, 0400, show_channels, NULL);
1936
1937 static void notify_wx_assoc_event(struct ipw_priv *priv)
1938 {
1939 union iwreq_data wrqu;
1940 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1941 if (priv->status & STATUS_ASSOCIATED)
1942 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1943 else
1944 eth_zero_addr(wrqu.ap_addr.sa_data);
1945 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1946 }
1947
1948 static void ipw_irq_tasklet(unsigned long data)
1949 {
1950 struct ipw_priv *priv = (struct ipw_priv *)data;
1951 u32 inta, inta_mask, handled = 0;
1952 unsigned long flags;
1953 int rc = 0;
1954
1955 spin_lock_irqsave(&priv->irq_lock, flags);
1956
1957 inta = ipw_read32(priv, IPW_INTA_RW);
1958 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1959
1960 if (inta == 0xFFFFFFFF) {
1961
1962 IPW_WARNING("TASKLET INTA == 0xFFFFFFFF\n");
1963
1964 inta = 0;
1965 }
1966 inta &= (IPW_INTA_MASK_ALL & inta_mask);
1967
1968
1969 inta |= priv->isr_inta;
1970
1971 spin_unlock_irqrestore(&priv->irq_lock, flags);
1972
1973 spin_lock_irqsave(&priv->lock, flags);
1974
1975
1976 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1977 ipw_rx(priv);
1978 handled |= IPW_INTA_BIT_RX_TRANSFER;
1979 }
1980
1981 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1982 IPW_DEBUG_HC("Command completed.\n");
1983 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1984 priv->status &= ~STATUS_HCMD_ACTIVE;
1985 wake_up_interruptible(&priv->wait_command_queue);
1986 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1987 }
1988
1989 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1990 IPW_DEBUG_TX("TX_QUEUE_1\n");
1991 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1992 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1993 }
1994
1995 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1996 IPW_DEBUG_TX("TX_QUEUE_2\n");
1997 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1998 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1999 }
2000
2001 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
2002 IPW_DEBUG_TX("TX_QUEUE_3\n");
2003 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
2004 handled |= IPW_INTA_BIT_TX_QUEUE_3;
2005 }
2006
2007 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
2008 IPW_DEBUG_TX("TX_QUEUE_4\n");
2009 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
2010 handled |= IPW_INTA_BIT_TX_QUEUE_4;
2011 }
2012
2013 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
2014 IPW_WARNING("STATUS_CHANGE\n");
2015 handled |= IPW_INTA_BIT_STATUS_CHANGE;
2016 }
2017
2018 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
2019 IPW_WARNING("TX_PERIOD_EXPIRED\n");
2020 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
2021 }
2022
2023 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
2024 IPW_WARNING("HOST_CMD_DONE\n");
2025 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
2026 }
2027
2028 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
2029 IPW_WARNING("FW_INITIALIZATION_DONE\n");
2030 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
2031 }
2032
2033 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
2034 IPW_WARNING("PHY_OFF_DONE\n");
2035 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
2036 }
2037
2038 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
2039 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
2040 priv->status |= STATUS_RF_KILL_HW;
2041 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
2042 wake_up_interruptible(&priv->wait_command_queue);
2043 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2044 cancel_delayed_work(&priv->request_scan);
2045 cancel_delayed_work(&priv->request_direct_scan);
2046 cancel_delayed_work(&priv->request_passive_scan);
2047 cancel_delayed_work(&priv->scan_event);
2048 schedule_work(&priv->link_down);
2049 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
2050 handled |= IPW_INTA_BIT_RF_KILL_DONE;
2051 }
2052
2053 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
2054 IPW_WARNING("Firmware error detected. Restarting.\n");
2055 if (priv->error) {
2056 IPW_DEBUG_FW("Sysfs 'error' log already exists.\n");
2057 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
2058 struct ipw_fw_error *error =
2059 ipw_alloc_error_log(priv);
2060 ipw_dump_error_log(priv, error);
2061 kfree(error);
2062 }
2063 } else {
2064 priv->error = ipw_alloc_error_log(priv);
2065 if (priv->error)
2066 IPW_DEBUG_FW("Sysfs 'error' log captured.\n");
2067 else
2068 IPW_DEBUG_FW("Error allocating sysfs 'error' "
2069 "log.\n");
2070 if (ipw_debug_level & IPW_DL_FW_ERRORS)
2071 ipw_dump_error_log(priv, priv->error);
2072 }
2073
2074
2075
2076 if (priv->ieee->sec.encrypt) {
2077 priv->status &= ~STATUS_ASSOCIATED;
2078 notify_wx_assoc_event(priv);
2079 }
2080
2081
2082
2083 priv->status &= ~STATUS_INIT;
2084
2085
2086 priv->status &= ~STATUS_HCMD_ACTIVE;
2087 wake_up_interruptible(&priv->wait_command_queue);
2088
2089 schedule_work(&priv->adapter_restart);
2090 handled |= IPW_INTA_BIT_FATAL_ERROR;
2091 }
2092
2093 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
2094 IPW_ERROR("Parity error\n");
2095 handled |= IPW_INTA_BIT_PARITY_ERROR;
2096 }
2097
2098 if (handled != inta) {
2099 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
2100 }
2101
2102 spin_unlock_irqrestore(&priv->lock, flags);
2103
2104
2105 ipw_enable_interrupts(priv);
2106 }
2107
2108 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
2109 static char *get_cmd_string(u8 cmd)
2110 {
2111 switch (cmd) {
2112 IPW_CMD(HOST_COMPLETE);
2113 IPW_CMD(POWER_DOWN);
2114 IPW_CMD(SYSTEM_CONFIG);
2115 IPW_CMD(MULTICAST_ADDRESS);
2116 IPW_CMD(SSID);
2117 IPW_CMD(ADAPTER_ADDRESS);
2118 IPW_CMD(PORT_TYPE);
2119 IPW_CMD(RTS_THRESHOLD);
2120 IPW_CMD(FRAG_THRESHOLD);
2121 IPW_CMD(POWER_MODE);
2122 IPW_CMD(WEP_KEY);
2123 IPW_CMD(TGI_TX_KEY);
2124 IPW_CMD(SCAN_REQUEST);
2125 IPW_CMD(SCAN_REQUEST_EXT);
2126 IPW_CMD(ASSOCIATE);
2127 IPW_CMD(SUPPORTED_RATES);
2128 IPW_CMD(SCAN_ABORT);
2129 IPW_CMD(TX_FLUSH);
2130 IPW_CMD(QOS_PARAMETERS);
2131 IPW_CMD(DINO_CONFIG);
2132 IPW_CMD(RSN_CAPABILITIES);
2133 IPW_CMD(RX_KEY);
2134 IPW_CMD(CARD_DISABLE);
2135 IPW_CMD(SEED_NUMBER);
2136 IPW_CMD(TX_POWER);
2137 IPW_CMD(COUNTRY_INFO);
2138 IPW_CMD(AIRONET_INFO);
2139 IPW_CMD(AP_TX_POWER);
2140 IPW_CMD(CCKM_INFO);
2141 IPW_CMD(CCX_VER_INFO);
2142 IPW_CMD(SET_CALIBRATION);
2143 IPW_CMD(SENSITIVITY_CALIB);
2144 IPW_CMD(RETRY_LIMIT);
2145 IPW_CMD(IPW_PRE_POWER_DOWN);
2146 IPW_CMD(VAP_BEACON_TEMPLATE);
2147 IPW_CMD(VAP_DTIM_PERIOD);
2148 IPW_CMD(EXT_SUPPORTED_RATES);
2149 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
2150 IPW_CMD(VAP_QUIET_INTERVALS);
2151 IPW_CMD(VAP_CHANNEL_SWITCH);
2152 IPW_CMD(VAP_MANDATORY_CHANNELS);
2153 IPW_CMD(VAP_CELL_PWR_LIMIT);
2154 IPW_CMD(VAP_CF_PARAM_SET);
2155 IPW_CMD(VAP_SET_BEACONING_STATE);
2156 IPW_CMD(MEASUREMENT);
2157 IPW_CMD(POWER_CAPABILITY);
2158 IPW_CMD(SUPPORTED_CHANNELS);
2159 IPW_CMD(TPC_REPORT);
2160 IPW_CMD(WME_INFO);
2161 IPW_CMD(PRODUCTION_COMMAND);
2162 default:
2163 return "UNKNOWN";
2164 }
2165 }
2166
2167 #define HOST_COMPLETE_TIMEOUT HZ
2168
2169 static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
2170 {
2171 int rc = 0;
2172 unsigned long flags;
2173 unsigned long now, end;
2174
2175 spin_lock_irqsave(&priv->lock, flags);
2176 if (priv->status & STATUS_HCMD_ACTIVE) {
2177 IPW_ERROR("Failed to send %s: Already sending a command.\n",
2178 get_cmd_string(cmd->cmd));
2179 spin_unlock_irqrestore(&priv->lock, flags);
2180 return -EAGAIN;
2181 }
2182
2183 priv->status |= STATUS_HCMD_ACTIVE;
2184
2185 if (priv->cmdlog) {
2186 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
2187 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
2188 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
2189 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
2190 cmd->len);
2191 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
2192 }
2193
2194 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
2195 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
2196 priv->status);
2197
2198 #ifndef DEBUG_CMD_WEP_KEY
2199 if (cmd->cmd == IPW_CMD_WEP_KEY)
2200 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
2201 else
2202 #endif
2203 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
2204
2205 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
2206 if (rc) {
2207 priv->status &= ~STATUS_HCMD_ACTIVE;
2208 IPW_ERROR("Failed to send %s: Reason %d\n",
2209 get_cmd_string(cmd->cmd), rc);
2210 spin_unlock_irqrestore(&priv->lock, flags);
2211 goto exit;
2212 }
2213 spin_unlock_irqrestore(&priv->lock, flags);
2214
2215 now = jiffies;
2216 end = now + HOST_COMPLETE_TIMEOUT;
2217 again:
2218 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
2219 !(priv->
2220 status & STATUS_HCMD_ACTIVE),
2221 end - now);
2222 if (rc < 0) {
2223 now = jiffies;
2224 if (time_before(now, end))
2225 goto again;
2226 rc = 0;
2227 }
2228
2229 if (rc == 0) {
2230 spin_lock_irqsave(&priv->lock, flags);
2231 if (priv->status & STATUS_HCMD_ACTIVE) {
2232 IPW_ERROR("Failed to send %s: Command timed out.\n",
2233 get_cmd_string(cmd->cmd));
2234 priv->status &= ~STATUS_HCMD_ACTIVE;
2235 spin_unlock_irqrestore(&priv->lock, flags);
2236 rc = -EIO;
2237 goto exit;
2238 }
2239 spin_unlock_irqrestore(&priv->lock, flags);
2240 } else
2241 rc = 0;
2242
2243 if (priv->status & STATUS_RF_KILL_HW) {
2244 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
2245 get_cmd_string(cmd->cmd));
2246 rc = -EIO;
2247 goto exit;
2248 }
2249
2250 exit:
2251 if (priv->cmdlog) {
2252 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
2253 priv->cmdlog_pos %= priv->cmdlog_len;
2254 }
2255 return rc;
2256 }
2257
2258 static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
2259 {
2260 struct host_cmd cmd = {
2261 .cmd = command,
2262 };
2263
2264 return __ipw_send_cmd(priv, &cmd);
2265 }
2266
2267 static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2268 void *data)
2269 {
2270 struct host_cmd cmd = {
2271 .cmd = command,
2272 .len = len,
2273 .param = data,
2274 };
2275
2276 return __ipw_send_cmd(priv, &cmd);
2277 }
2278
2279 static int ipw_send_host_complete(struct ipw_priv *priv)
2280 {
2281 if (!priv) {
2282 IPW_ERROR("Invalid args\n");
2283 return -1;
2284 }
2285
2286 return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
2287 }
2288
2289 static int ipw_send_system_config(struct ipw_priv *priv)
2290 {
2291 return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG,
2292 sizeof(priv->sys_config),
2293 &priv->sys_config);
2294 }
2295
2296 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
2297 {
2298 if (!priv || !ssid) {
2299 IPW_ERROR("Invalid args\n");
2300 return -1;
2301 }
2302
2303 return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
2304 ssid);
2305 }
2306
2307 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
2308 {
2309 if (!priv || !mac) {
2310 IPW_ERROR("Invalid args\n");
2311 return -1;
2312 }
2313
2314 IPW_DEBUG_INFO("%s: Setting MAC to %pM\n",
2315 priv->net_dev->name, mac);
2316
2317 return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
2318 }
2319
2320 static void ipw_adapter_restart(void *adapter)
2321 {
2322 struct ipw_priv *priv = adapter;
2323
2324 if (priv->status & STATUS_RF_KILL_MASK)
2325 return;
2326
2327 ipw_down(priv);
2328
2329 if (priv->assoc_network &&
2330 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2331 ipw_remove_current_network(priv);
2332
2333 if (ipw_up(priv)) {
2334 IPW_ERROR("Failed to up device\n");
2335 return;
2336 }
2337 }
2338
2339 static void ipw_bg_adapter_restart(struct work_struct *work)
2340 {
2341 struct ipw_priv *priv =
2342 container_of(work, struct ipw_priv, adapter_restart);
2343 mutex_lock(&priv->mutex);
2344 ipw_adapter_restart(priv);
2345 mutex_unlock(&priv->mutex);
2346 }
2347
2348 static void ipw_abort_scan(struct ipw_priv *priv);
2349
2350 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2351
2352 static void ipw_scan_check(void *data)
2353 {
2354 struct ipw_priv *priv = data;
2355
2356 if (priv->status & STATUS_SCAN_ABORTING) {
2357 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2358 "adapter after (%dms).\n",
2359 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2360 schedule_work(&priv->adapter_restart);
2361 } else if (priv->status & STATUS_SCANNING) {
2362 IPW_DEBUG_SCAN("Scan completion watchdog aborting scan "
2363 "after (%dms).\n",
2364 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2365 ipw_abort_scan(priv);
2366 schedule_delayed_work(&priv->scan_check, HZ);
2367 }
2368 }
2369
2370 static void ipw_bg_scan_check(struct work_struct *work)
2371 {
2372 struct ipw_priv *priv =
2373 container_of(work, struct ipw_priv, scan_check.work);
2374 mutex_lock(&priv->mutex);
2375 ipw_scan_check(priv);
2376 mutex_unlock(&priv->mutex);
2377 }
2378
2379 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2380 struct ipw_scan_request_ext *request)
2381 {
2382 return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
2383 sizeof(*request), request);
2384 }
2385
2386 static int ipw_send_scan_abort(struct ipw_priv *priv)
2387 {
2388 if (!priv) {
2389 IPW_ERROR("Invalid args\n");
2390 return -1;
2391 }
2392
2393 return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
2394 }
2395
2396 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2397 {
2398 struct ipw_sensitivity_calib calib = {
2399 .beacon_rssi_raw = cpu_to_le16(sens),
2400 };
2401
2402 return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
2403 &calib);
2404 }
2405
2406 static int ipw_send_associate(struct ipw_priv *priv,
2407 struct ipw_associate *associate)
2408 {
2409 if (!priv || !associate) {
2410 IPW_ERROR("Invalid args\n");
2411 return -1;
2412 }
2413
2414 return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(*associate),
2415 associate);
2416 }
2417
2418 static int ipw_send_supported_rates(struct ipw_priv *priv,
2419 struct ipw_supported_rates *rates)
2420 {
2421 if (!priv || !rates) {
2422 IPW_ERROR("Invalid args\n");
2423 return -1;
2424 }
2425
2426 return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
2427 rates);
2428 }
2429
2430 static int ipw_set_random_seed(struct ipw_priv *priv)
2431 {
2432 u32 val;
2433
2434 if (!priv) {
2435 IPW_ERROR("Invalid args\n");
2436 return -1;
2437 }
2438
2439 get_random_bytes(&val, sizeof(val));
2440
2441 return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
2442 }
2443
2444 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2445 {
2446 __le32 v = cpu_to_le32(phy_off);
2447 if (!priv) {
2448 IPW_ERROR("Invalid args\n");
2449 return -1;
2450 }
2451
2452 return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(v), &v);
2453 }
2454
2455 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2456 {
2457 if (!priv || !power) {
2458 IPW_ERROR("Invalid args\n");
2459 return -1;
2460 }
2461
2462 return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
2463 }
2464
2465 static int ipw_set_tx_power(struct ipw_priv *priv)
2466 {
2467 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
2468 struct ipw_tx_power tx_power;
2469 s8 max_power;
2470 int i;
2471
2472 memset(&tx_power, 0, sizeof(tx_power));
2473
2474
2475 tx_power.ieee_mode = IPW_G_MODE;
2476 tx_power.num_channels = geo->bg_channels;
2477 for (i = 0; i < geo->bg_channels; i++) {
2478 max_power = geo->bg[i].max_power;
2479 tx_power.channels_tx_power[i].channel_number =
2480 geo->bg[i].channel;
2481 tx_power.channels_tx_power[i].tx_power = max_power ?
2482 min(max_power, priv->tx_power) : priv->tx_power;
2483 }
2484 if (ipw_send_tx_power(priv, &tx_power))
2485 return -EIO;
2486
2487
2488 tx_power.ieee_mode = IPW_B_MODE;
2489 if (ipw_send_tx_power(priv, &tx_power))
2490 return -EIO;
2491
2492
2493 if (priv->ieee->abg_true) {
2494 tx_power.ieee_mode = IPW_A_MODE;
2495 tx_power.num_channels = geo->a_channels;
2496 for (i = 0; i < tx_power.num_channels; i++) {
2497 max_power = geo->a[i].max_power;
2498 tx_power.channels_tx_power[i].channel_number =
2499 geo->a[i].channel;
2500 tx_power.channels_tx_power[i].tx_power = max_power ?
2501 min(max_power, priv->tx_power) : priv->tx_power;
2502 }
2503 if (ipw_send_tx_power(priv, &tx_power))
2504 return -EIO;
2505 }
2506 return 0;
2507 }
2508
2509 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2510 {
2511 struct ipw_rts_threshold rts_threshold = {
2512 .rts_threshold = cpu_to_le16(rts),
2513 };
2514
2515 if (!priv) {
2516 IPW_ERROR("Invalid args\n");
2517 return -1;
2518 }
2519
2520 return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2521 sizeof(rts_threshold), &rts_threshold);
2522 }
2523
2524 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2525 {
2526 struct ipw_frag_threshold frag_threshold = {
2527 .frag_threshold = cpu_to_le16(frag),
2528 };
2529
2530 if (!priv) {
2531 IPW_ERROR("Invalid args\n");
2532 return -1;
2533 }
2534
2535 return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2536 sizeof(frag_threshold), &frag_threshold);
2537 }
2538
2539 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2540 {
2541 __le32 param;
2542
2543 if (!priv) {
2544 IPW_ERROR("Invalid args\n");
2545 return -1;
2546 }
2547
2548
2549
2550 switch (mode) {
2551 case IPW_POWER_BATTERY:
2552 param = cpu_to_le32(IPW_POWER_INDEX_3);
2553 break;
2554 case IPW_POWER_AC:
2555 param = cpu_to_le32(IPW_POWER_MODE_CAM);
2556 break;
2557 default:
2558 param = cpu_to_le32(mode);
2559 break;
2560 }
2561
2562 return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
2563 ¶m);
2564 }
2565
2566 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2567 {
2568 struct ipw_retry_limit retry_limit = {
2569 .short_retry_limit = slimit,
2570 .long_retry_limit = llimit
2571 };
2572
2573 if (!priv) {
2574 IPW_ERROR("Invalid args\n");
2575 return -1;
2576 }
2577
2578 return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
2579 &retry_limit);
2580 }
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2601 {
2602 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2603
2604
2605 udelay(p->eeprom_delay);
2606 }
2607
2608
2609 static void eeprom_cs(struct ipw_priv *priv)
2610 {
2611 eeprom_write_reg(priv, 0);
2612 eeprom_write_reg(priv, EEPROM_BIT_CS);
2613 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2614 eeprom_write_reg(priv, EEPROM_BIT_CS);
2615 }
2616
2617
2618 static void eeprom_disable_cs(struct ipw_priv *priv)
2619 {
2620 eeprom_write_reg(priv, EEPROM_BIT_CS);
2621 eeprom_write_reg(priv, 0);
2622 eeprom_write_reg(priv, EEPROM_BIT_SK);
2623 }
2624
2625
2626 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2627 {
2628 int d = (bit ? EEPROM_BIT_DI : 0);
2629 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2630 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2631 }
2632
2633
2634 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2635 {
2636 int i;
2637
2638 eeprom_cs(priv);
2639 eeprom_write_bit(priv, 1);
2640 eeprom_write_bit(priv, op & 2);
2641 eeprom_write_bit(priv, op & 1);
2642 for (i = 7; i >= 0; i--) {
2643 eeprom_write_bit(priv, addr & (1 << i));
2644 }
2645 }
2646
2647
2648 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2649 {
2650 int i;
2651 u16 r = 0;
2652
2653
2654 eeprom_op(priv, EEPROM_CMD_READ, addr);
2655
2656
2657 eeprom_write_reg(priv, EEPROM_BIT_CS);
2658
2659
2660 for (i = 0; i < 16; i++) {
2661 u32 data = 0;
2662 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2663 eeprom_write_reg(priv, EEPROM_BIT_CS);
2664 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2665 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2666 }
2667
2668
2669 eeprom_write_reg(priv, 0);
2670 eeprom_disable_cs(priv);
2671
2672 return r;
2673 }
2674
2675
2676
2677 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2678 {
2679 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], ETH_ALEN);
2680 }
2681
2682 static void ipw_read_eeprom(struct ipw_priv *priv)
2683 {
2684 int i;
2685 __le16 *eeprom = (__le16 *) priv->eeprom;
2686
2687 IPW_DEBUG_TRACE(">>\n");
2688
2689
2690 for (i = 0; i < 128; i++)
2691 eeprom[i] = cpu_to_le16(eeprom_read_u16(priv, (u8) i));
2692
2693 IPW_DEBUG_TRACE("<<\n");
2694 }
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2705 {
2706 int i;
2707
2708 IPW_DEBUG_TRACE(">>\n");
2709
2710
2711
2712
2713
2714
2715 if (priv->eeprom[EEPROM_VERSION] != 0) {
2716 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2717
2718
2719 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2720 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2721
2722
2723 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2724 } else {
2725 IPW_DEBUG_INFO("Enabling FW initialization of SRAM\n");
2726
2727
2728 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2729 }
2730
2731 IPW_DEBUG_TRACE("<<\n");
2732 }
2733
2734 static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2735 {
2736 count >>= 2;
2737 if (!count)
2738 return;
2739 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2740 while (count--)
2741 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2742 }
2743
2744 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2745 {
2746 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2747 CB_NUMBER_OF_ELEMENTS_SMALL *
2748 sizeof(struct command_block));
2749 }
2750
2751 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2752 {
2753
2754 IPW_DEBUG_FW(">> :\n");
2755
2756
2757 ipw_fw_dma_reset_command_blocks(priv);
2758
2759
2760 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2761
2762 IPW_DEBUG_FW("<< :\n");
2763 return 0;
2764 }
2765
2766 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2767 {
2768 u32 control = 0;
2769
2770 IPW_DEBUG_FW(">> :\n");
2771
2772
2773 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2774 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2775 priv->sram_desc.last_cb_index = 0;
2776
2777 IPW_DEBUG_FW("<<\n");
2778 }
2779
2780 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2781 struct command_block *cb)
2782 {
2783 u32 address =
2784 IPW_SHARED_SRAM_DMA_CONTROL +
2785 (sizeof(struct command_block) * index);
2786 IPW_DEBUG_FW(">> :\n");
2787
2788 ipw_write_indirect(priv, address, (u8 *) cb,
2789 (int)sizeof(struct command_block));
2790
2791 IPW_DEBUG_FW("<< :\n");
2792 return 0;
2793
2794 }
2795
2796 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2797 {
2798 u32 control = 0;
2799 u32 index = 0;
2800
2801 IPW_DEBUG_FW(">> :\n");
2802
2803 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2804 ipw_fw_dma_write_command_block(priv, index,
2805 &priv->sram_desc.cb_list[index]);
2806
2807
2808 ipw_clear_bit(priv, IPW_RESET_REG,
2809 IPW_RESET_REG_MASTER_DISABLED |
2810 IPW_RESET_REG_STOP_MASTER);
2811
2812
2813 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2814 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2815
2816 IPW_DEBUG_FW("<< :\n");
2817 return 0;
2818 }
2819
2820 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2821 {
2822 u32 address;
2823 u32 register_value = 0;
2824 u32 cb_fields_address = 0;
2825
2826 IPW_DEBUG_FW(">> :\n");
2827 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2828 IPW_DEBUG_FW_INFO("Current CB is 0x%x\n", address);
2829
2830
2831 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2832 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x\n", register_value);
2833
2834
2835 cb_fields_address = address;
2836 register_value = ipw_read_reg32(priv, cb_fields_address);
2837 IPW_DEBUG_FW_INFO("Current CB Control Field is 0x%x\n", register_value);
2838
2839 cb_fields_address += sizeof(u32);
2840 register_value = ipw_read_reg32(priv, cb_fields_address);
2841 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x\n", register_value);
2842
2843 cb_fields_address += sizeof(u32);
2844 register_value = ipw_read_reg32(priv, cb_fields_address);
2845 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x\n",
2846 register_value);
2847
2848 cb_fields_address += sizeof(u32);
2849 register_value = ipw_read_reg32(priv, cb_fields_address);
2850 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x\n", register_value);
2851
2852 IPW_DEBUG_FW(">> :\n");
2853 }
2854
2855 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2856 {
2857 u32 current_cb_address = 0;
2858 u32 current_cb_index = 0;
2859
2860 IPW_DEBUG_FW("<< :\n");
2861 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2862
2863 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2864 sizeof(struct command_block);
2865
2866 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X\n",
2867 current_cb_index, current_cb_address);
2868
2869 IPW_DEBUG_FW(">> :\n");
2870 return current_cb_index;
2871
2872 }
2873
2874 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2875 u32 src_address,
2876 u32 dest_address,
2877 u32 length,
2878 int interrupt_enabled, int is_last)
2879 {
2880
2881 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2882 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2883 CB_DEST_SIZE_LONG;
2884 struct command_block *cb;
2885 u32 last_cb_element = 0;
2886
2887 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2888 src_address, dest_address, length);
2889
2890 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2891 return -1;
2892
2893 last_cb_element = priv->sram_desc.last_cb_index;
2894 cb = &priv->sram_desc.cb_list[last_cb_element];
2895 priv->sram_desc.last_cb_index++;
2896
2897
2898 if (interrupt_enabled)
2899 control |= CB_INT_ENABLED;
2900
2901 if (is_last)
2902 control |= CB_LAST_VALID;
2903
2904 control |= length;
2905
2906
2907 cb->status = control ^ src_address ^ dest_address;
2908
2909
2910 cb->dest_addr = dest_address;
2911 cb->source_addr = src_address;
2912
2913
2914 cb->control = control;
2915
2916 return 0;
2917 }
2918
2919 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv, dma_addr_t *src_address,
2920 int nr, u32 dest_address, u32 len)
2921 {
2922 int ret, i;
2923 u32 size;
2924
2925 IPW_DEBUG_FW(">>\n");
2926 IPW_DEBUG_FW_INFO("nr=%d dest_address=0x%x len=0x%x\n",
2927 nr, dest_address, len);
2928
2929 for (i = 0; i < nr; i++) {
2930 size = min_t(u32, len - i * CB_MAX_LENGTH, CB_MAX_LENGTH);
2931 ret = ipw_fw_dma_add_command_block(priv, src_address[i],
2932 dest_address +
2933 i * CB_MAX_LENGTH, size,
2934 0, 0);
2935 if (ret) {
2936 IPW_DEBUG_FW_INFO(": Failed\n");
2937 return -1;
2938 } else
2939 IPW_DEBUG_FW_INFO(": Added new cb\n");
2940 }
2941
2942 IPW_DEBUG_FW("<<\n");
2943 return 0;
2944 }
2945
2946 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2947 {
2948 u32 current_index = 0, previous_index;
2949 u32 watchdog = 0;
2950
2951 IPW_DEBUG_FW(">> :\n");
2952
2953 current_index = ipw_fw_dma_command_block_index(priv);
2954 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
2955 (int)priv->sram_desc.last_cb_index);
2956
2957 while (current_index < priv->sram_desc.last_cb_index) {
2958 udelay(50);
2959 previous_index = current_index;
2960 current_index = ipw_fw_dma_command_block_index(priv);
2961
2962 if (previous_index < current_index) {
2963 watchdog = 0;
2964 continue;
2965 }
2966 if (++watchdog > 400) {
2967 IPW_DEBUG_FW_INFO("Timeout\n");
2968 ipw_fw_dma_dump_command_block(priv);
2969 ipw_fw_dma_abort(priv);
2970 return -1;
2971 }
2972 }
2973
2974 ipw_fw_dma_abort(priv);
2975
2976
2977 ipw_set_bit(priv, IPW_RESET_REG,
2978 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2979
2980 IPW_DEBUG_FW("<< dmaWaitSync\n");
2981 return 0;
2982 }
2983
2984 static void ipw_remove_current_network(struct ipw_priv *priv)
2985 {
2986 struct list_head *element, *safe;
2987 struct libipw_network *network = NULL;
2988 unsigned long flags;
2989
2990 spin_lock_irqsave(&priv->ieee->lock, flags);
2991 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2992 network = list_entry(element, struct libipw_network, list);
2993 if (ether_addr_equal(network->bssid, priv->bssid)) {
2994 list_del(element);
2995 list_add_tail(&network->list,
2996 &priv->ieee->network_free_list);
2997 }
2998 }
2999 spin_unlock_irqrestore(&priv->ieee->lock, flags);
3000 }
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011 static inline int ipw_alive(struct ipw_priv *priv)
3012 {
3013 return ipw_read32(priv, 0x90) == 0xd55555d5;
3014 }
3015
3016
3017 static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
3018 int timeout)
3019 {
3020 int i = 0;
3021
3022 do {
3023 if ((ipw_read32(priv, addr) & mask) == mask)
3024 return i;
3025 mdelay(10);
3026 i += 10;
3027 } while (i < timeout);
3028
3029 return -ETIME;
3030 }
3031
3032
3033
3034
3035
3036
3037 static int ipw_stop_master(struct ipw_priv *priv)
3038 {
3039 int rc;
3040
3041 IPW_DEBUG_TRACE(">>\n");
3042
3043 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3044
3045
3046 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3047 IPW_RESET_REG_MASTER_DISABLED, 100);
3048 if (rc < 0) {
3049 IPW_ERROR("wait for stop master failed after 100ms\n");
3050 return -1;
3051 }
3052
3053 IPW_DEBUG_INFO("stop master %dms\n", rc);
3054
3055 return rc;
3056 }
3057
3058 static void ipw_arc_release(struct ipw_priv *priv)
3059 {
3060 IPW_DEBUG_TRACE(">>\n");
3061 mdelay(5);
3062
3063 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3064
3065
3066 mdelay(5);
3067 }
3068
3069 struct fw_chunk {
3070 __le32 address;
3071 __le32 length;
3072 };
3073
3074 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
3075 {
3076 int rc = 0, i, addr;
3077 u8 cr = 0;
3078 __le16 *image;
3079
3080 image = (__le16 *) data;
3081
3082 IPW_DEBUG_TRACE(">>\n");
3083
3084 rc = ipw_stop_master(priv);
3085
3086 if (rc < 0)
3087 return rc;
3088
3089 for (addr = IPW_SHARED_LOWER_BOUND;
3090 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
3091 ipw_write32(priv, addr, 0);
3092 }
3093
3094
3095 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
3096
3097
3098
3099 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
3100 ipw_arc_release(priv);
3101 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
3102 mdelay(1);
3103
3104
3105 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
3106 mdelay(1);
3107
3108 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
3109 mdelay(1);
3110
3111
3112 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
3113 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
3114 mdelay(1);
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125 for (i = 0; i < len / 2; i++)
3126 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
3127 le16_to_cpu(image[i]));
3128
3129
3130 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3131 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
3132
3133
3134
3135
3136 for (i = 0; i < 100; i++) {
3137
3138 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
3139 if (cr & DINO_RXFIFO_DATA)
3140 break;
3141 mdelay(1);
3142 }
3143
3144 if (cr & DINO_RXFIFO_DATA) {
3145
3146 __le32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
3147
3148 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
3149 response_buffer[i] =
3150 cpu_to_le32(ipw_read_reg32(priv,
3151 IPW_BASEBAND_RX_FIFO_READ));
3152 memcpy(&priv->dino_alive, response_buffer,
3153 sizeof(priv->dino_alive));
3154 if (priv->dino_alive.alive_command == 1
3155 && priv->dino_alive.ucode_valid == 1) {
3156 rc = 0;
3157 IPW_DEBUG_INFO
3158 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
3159 "of %02d/%02d/%02d %02d:%02d\n",
3160 priv->dino_alive.software_revision,
3161 priv->dino_alive.software_revision,
3162 priv->dino_alive.device_identifier,
3163 priv->dino_alive.device_identifier,
3164 priv->dino_alive.time_stamp[0],
3165 priv->dino_alive.time_stamp[1],
3166 priv->dino_alive.time_stamp[2],
3167 priv->dino_alive.time_stamp[3],
3168 priv->dino_alive.time_stamp[4]);
3169 } else {
3170 IPW_DEBUG_INFO("Microcode is not alive\n");
3171 rc = -EINVAL;
3172 }
3173 } else {
3174 IPW_DEBUG_INFO("No alive response from DINO\n");
3175 rc = -ETIME;
3176 }
3177
3178
3179
3180 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3181
3182 return rc;
3183 }
3184
3185 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
3186 {
3187 int ret = -1;
3188 int offset = 0;
3189 struct fw_chunk *chunk;
3190 int total_nr = 0;
3191 int i;
3192 struct dma_pool *pool;
3193 void **virts;
3194 dma_addr_t *phys;
3195
3196 IPW_DEBUG_TRACE("<< :\n");
3197
3198 virts = kmalloc_array(CB_NUMBER_OF_ELEMENTS_SMALL, sizeof(void *),
3199 GFP_KERNEL);
3200 if (!virts)
3201 return -ENOMEM;
3202
3203 phys = kmalloc_array(CB_NUMBER_OF_ELEMENTS_SMALL, sizeof(dma_addr_t),
3204 GFP_KERNEL);
3205 if (!phys) {
3206 kfree(virts);
3207 return -ENOMEM;
3208 }
3209 pool = dma_pool_create("ipw2200", &priv->pci_dev->dev, CB_MAX_LENGTH, 0,
3210 0);
3211 if (!pool) {
3212 IPW_ERROR("dma_pool_create failed\n");
3213 kfree(phys);
3214 kfree(virts);
3215 return -ENOMEM;
3216 }
3217
3218
3219 ret = ipw_fw_dma_enable(priv);
3220
3221
3222 BUG_ON(priv->sram_desc.last_cb_index > 0);
3223
3224 do {
3225 u32 chunk_len;
3226 u8 *start;
3227 int size;
3228 int nr = 0;
3229
3230 chunk = (struct fw_chunk *)(data + offset);
3231 offset += sizeof(struct fw_chunk);
3232 chunk_len = le32_to_cpu(chunk->length);
3233 start = data + offset;
3234
3235 nr = (chunk_len + CB_MAX_LENGTH - 1) / CB_MAX_LENGTH;
3236 for (i = 0; i < nr; i++) {
3237 virts[total_nr] = dma_pool_alloc(pool, GFP_KERNEL,
3238 &phys[total_nr]);
3239 if (!virts[total_nr]) {
3240 ret = -ENOMEM;
3241 goto out;
3242 }
3243 size = min_t(u32, chunk_len - i * CB_MAX_LENGTH,
3244 CB_MAX_LENGTH);
3245 memcpy(virts[total_nr], start, size);
3246 start += size;
3247 total_nr++;
3248
3249 BUG_ON(total_nr > CB_NUMBER_OF_ELEMENTS_SMALL);
3250 }
3251
3252
3253
3254
3255
3256 ret = ipw_fw_dma_add_buffer(priv, &phys[total_nr - nr],
3257 nr, le32_to_cpu(chunk->address),
3258 chunk_len);
3259 if (ret) {
3260 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3261 goto out;
3262 }
3263
3264 offset += chunk_len;
3265 } while (offset < len);
3266
3267
3268 ret = ipw_fw_dma_kick(priv);
3269 if (ret) {
3270 IPW_ERROR("dmaKick Failed\n");
3271 goto out;
3272 }
3273
3274 ret = ipw_fw_dma_wait(priv);
3275 if (ret) {
3276 IPW_ERROR("dmaWaitSync Failed\n");
3277 goto out;
3278 }
3279 out:
3280 for (i = 0; i < total_nr; i++)
3281 dma_pool_free(pool, virts[i], phys[i]);
3282
3283 dma_pool_destroy(pool);
3284 kfree(phys);
3285 kfree(virts);
3286
3287 return ret;
3288 }
3289
3290
3291 static int ipw_stop_nic(struct ipw_priv *priv)
3292 {
3293 int rc = 0;
3294
3295
3296 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3297
3298 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3299 IPW_RESET_REG_MASTER_DISABLED, 500);
3300 if (rc < 0) {
3301 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
3302 return rc;
3303 }
3304
3305 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3306
3307 return rc;
3308 }
3309
3310 static void ipw_start_nic(struct ipw_priv *priv)
3311 {
3312 IPW_DEBUG_TRACE(">>\n");
3313
3314
3315 ipw_clear_bit(priv, IPW_RESET_REG,
3316 IPW_RESET_REG_MASTER_DISABLED |
3317 IPW_RESET_REG_STOP_MASTER |
3318 CBD_RESET_REG_PRINCETON_RESET);
3319
3320
3321 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3322 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3323
3324 IPW_DEBUG_TRACE("<<\n");
3325 }
3326
3327 static int ipw_init_nic(struct ipw_priv *priv)
3328 {
3329 int rc;
3330
3331 IPW_DEBUG_TRACE(">>\n");
3332
3333
3334
3335 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3336
3337
3338 ipw_write32(priv, IPW_READ_INT_REGISTER,
3339 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3340
3341
3342 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3343 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3344 if (rc < 0)
3345 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3346
3347
3348 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3349
3350 udelay(10);
3351
3352
3353 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3354
3355 IPW_DEBUG_TRACE(">>\n");
3356 return 0;
3357 }
3358
3359
3360
3361
3362 static int ipw_reset_nic(struct ipw_priv *priv)
3363 {
3364 int rc = 0;
3365 unsigned long flags;
3366
3367 IPW_DEBUG_TRACE(">>\n");
3368
3369 rc = ipw_init_nic(priv);
3370
3371 spin_lock_irqsave(&priv->lock, flags);
3372
3373 priv->status &= ~STATUS_HCMD_ACTIVE;
3374 wake_up_interruptible(&priv->wait_command_queue);
3375 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3376 wake_up_interruptible(&priv->wait_state);
3377 spin_unlock_irqrestore(&priv->lock, flags);
3378
3379 IPW_DEBUG_TRACE("<<\n");
3380 return rc;
3381 }
3382
3383
3384 struct ipw_fw {
3385 __le32 ver;
3386 __le32 boot_size;
3387 __le32 ucode_size;
3388 __le32 fw_size;
3389 u8 data[0];
3390 };
3391
3392 static int ipw_get_fw(struct ipw_priv *priv,
3393 const struct firmware **raw, const char *name)
3394 {
3395 struct ipw_fw *fw;
3396 int rc;
3397
3398
3399 rc = request_firmware(raw, name, &priv->pci_dev->dev);
3400 if (rc < 0) {
3401 IPW_ERROR("%s request_firmware failed: Reason %d\n", name, rc);
3402 return rc;
3403 }
3404
3405 if ((*raw)->size < sizeof(*fw)) {
3406 IPW_ERROR("%s is too small (%zd)\n", name, (*raw)->size);
3407 return -EINVAL;
3408 }
3409
3410 fw = (void *)(*raw)->data;
3411
3412 if ((*raw)->size < sizeof(*fw) + le32_to_cpu(fw->boot_size) +
3413 le32_to_cpu(fw->ucode_size) + le32_to_cpu(fw->fw_size)) {
3414 IPW_ERROR("%s is too small or corrupt (%zd)\n",
3415 name, (*raw)->size);
3416 return -EINVAL;
3417 }
3418
3419 IPW_DEBUG_INFO("Read firmware '%s' image v%d.%d (%zd bytes)\n",
3420 name,
3421 le32_to_cpu(fw->ver) >> 16,
3422 le32_to_cpu(fw->ver) & 0xff,
3423 (*raw)->size - sizeof(*fw));
3424 return 0;
3425 }
3426
3427 #define IPW_RX_BUF_SIZE (3000)
3428
3429 static void ipw_rx_queue_reset(struct ipw_priv *priv,
3430 struct ipw_rx_queue *rxq)
3431 {
3432 unsigned long flags;
3433 int i;
3434
3435 spin_lock_irqsave(&rxq->lock, flags);
3436
3437 INIT_LIST_HEAD(&rxq->rx_free);
3438 INIT_LIST_HEAD(&rxq->rx_used);
3439
3440
3441 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3442
3443
3444 if (rxq->pool[i].skb != NULL) {
3445 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3446 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3447 dev_kfree_skb(rxq->pool[i].skb);
3448 rxq->pool[i].skb = NULL;
3449 }
3450 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3451 }
3452
3453
3454
3455 rxq->read = rxq->write = 0;
3456 rxq->free_count = 0;
3457 spin_unlock_irqrestore(&rxq->lock, flags);
3458 }
3459
3460 #ifdef CONFIG_PM
3461 static int fw_loaded = 0;
3462 static const struct firmware *raw = NULL;
3463
3464 static void free_firmware(void)
3465 {
3466 if (fw_loaded) {
3467 release_firmware(raw);
3468 raw = NULL;
3469 fw_loaded = 0;
3470 }
3471 }
3472 #else
3473 #define free_firmware() do {} while (0)
3474 #endif
3475
3476 static int ipw_load(struct ipw_priv *priv)
3477 {
3478 #ifndef CONFIG_PM
3479 const struct firmware *raw = NULL;
3480 #endif
3481 struct ipw_fw *fw;
3482 u8 *boot_img, *ucode_img, *fw_img;
3483 u8 *name = NULL;
3484 int rc = 0, retries = 3;
3485
3486 switch (priv->ieee->iw_mode) {
3487 case IW_MODE_ADHOC:
3488 name = "ipw2200-ibss.fw";
3489 break;
3490 #ifdef CONFIG_IPW2200_MONITOR
3491 case IW_MODE_MONITOR:
3492 name = "ipw2200-sniffer.fw";
3493 break;
3494 #endif
3495 case IW_MODE_INFRA:
3496 name = "ipw2200-bss.fw";
3497 break;
3498 }
3499
3500 if (!name) {
3501 rc = -EINVAL;
3502 goto error;
3503 }
3504
3505 #ifdef CONFIG_PM
3506 if (!fw_loaded) {
3507 #endif
3508 rc = ipw_get_fw(priv, &raw, name);
3509 if (rc < 0)
3510 goto error;
3511 #ifdef CONFIG_PM
3512 }
3513 #endif
3514
3515 fw = (void *)raw->data;
3516 boot_img = &fw->data[0];
3517 ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3518 fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3519 le32_to_cpu(fw->ucode_size)];
3520
3521 if (!priv->rxq)
3522 priv->rxq = ipw_rx_queue_alloc(priv);
3523 else
3524 ipw_rx_queue_reset(priv, priv->rxq);
3525 if (!priv->rxq) {
3526 IPW_ERROR("Unable to initialize Rx queue\n");
3527 rc = -ENOMEM;
3528 goto error;
3529 }
3530
3531 retry:
3532
3533 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3534 priv->status &= ~STATUS_INT_ENABLED;
3535
3536
3537 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3538
3539 ipw_stop_nic(priv);
3540
3541 rc = ipw_reset_nic(priv);
3542 if (rc < 0) {
3543 IPW_ERROR("Unable to reset NIC\n");
3544 goto error;
3545 }
3546
3547 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3548 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3549
3550
3551 rc = ipw_load_firmware(priv, boot_img, le32_to_cpu(fw->boot_size));
3552 if (rc < 0) {
3553 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3554 goto error;
3555 }
3556
3557
3558 ipw_start_nic(priv);
3559
3560
3561 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3562 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3563 if (rc < 0) {
3564 IPW_ERROR("device failed to boot initial fw image\n");
3565 goto error;
3566 }
3567 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3568
3569
3570 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3571
3572
3573 rc = ipw_load_ucode(priv, ucode_img, le32_to_cpu(fw->ucode_size));
3574 if (rc < 0) {
3575 IPW_ERROR("Unable to load ucode: %d\n", rc);
3576 goto error;
3577 }
3578
3579
3580 ipw_stop_nic(priv);
3581
3582
3583 rc = ipw_load_firmware(priv, fw_img, le32_to_cpu(fw->fw_size));
3584 if (rc < 0) {
3585 IPW_ERROR("Unable to load firmware: %d\n", rc);
3586 goto error;
3587 }
3588 #ifdef CONFIG_PM
3589 fw_loaded = 1;
3590 #endif
3591
3592 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3593
3594 rc = ipw_queue_reset(priv);
3595 if (rc < 0) {
3596 IPW_ERROR("Unable to initialize queues\n");
3597 goto error;
3598 }
3599
3600
3601 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3602
3603 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3604
3605
3606 ipw_start_nic(priv);
3607
3608 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3609 if (retries > 0) {
3610 IPW_WARNING("Parity error. Retrying init.\n");
3611 retries--;
3612 goto retry;
3613 }
3614
3615 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3616 rc = -EIO;
3617 goto error;
3618 }
3619
3620
3621 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3622 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3623 if (rc < 0) {
3624 IPW_ERROR("device failed to start within 500ms\n");
3625 goto error;
3626 }
3627 IPW_DEBUG_INFO("device response after %dms\n", rc);
3628
3629
3630 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3631
3632
3633 priv->eeprom_delay = 1;
3634 ipw_read_eeprom(priv);
3635
3636 ipw_eeprom_init_sram(priv);
3637
3638
3639 ipw_enable_interrupts(priv);
3640
3641
3642 ipw_rx_queue_replenish(priv);
3643
3644 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3645
3646
3647 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3648
3649 #ifndef CONFIG_PM
3650 release_firmware(raw);
3651 #endif
3652 return 0;
3653
3654 error:
3655 if (priv->rxq) {
3656 ipw_rx_queue_free(priv, priv->rxq);
3657 priv->rxq = NULL;
3658 }
3659 ipw_tx_queue_free(priv);
3660 release_firmware(raw);
3661 #ifdef CONFIG_PM
3662 fw_loaded = 0;
3663 raw = NULL;
3664 #endif
3665
3666 return rc;
3667 }
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699 static int ipw_rx_queue_space(const struct ipw_rx_queue *q)
3700 {
3701 int s = q->read - q->write;
3702 if (s <= 0)
3703 s += RX_QUEUE_SIZE;
3704
3705 s -= 2;
3706 if (s < 0)
3707 s = 0;
3708 return s;
3709 }
3710
3711 static inline int ipw_tx_queue_space(const struct clx2_queue *q)
3712 {
3713 int s = q->last_used - q->first_empty;
3714 if (s <= 0)
3715 s += q->n_bd;
3716 s -= 2;
3717 if (s < 0)
3718 s = 0;
3719 return s;
3720 }
3721
3722 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3723 {
3724 return (++index == n_bd) ? 0 : index;
3725 }
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3742 int count, u32 read, u32 write, u32 base, u32 size)
3743 {
3744 q->n_bd = count;
3745
3746 q->low_mark = q->n_bd / 4;
3747 if (q->low_mark < 4)
3748 q->low_mark = 4;
3749
3750 q->high_mark = q->n_bd / 8;
3751 if (q->high_mark < 2)
3752 q->high_mark = 2;
3753
3754 q->first_empty = q->last_used = 0;
3755 q->reg_r = read;
3756 q->reg_w = write;
3757
3758 ipw_write32(priv, base, q->dma_addr);
3759 ipw_write32(priv, size, count);
3760 ipw_write32(priv, read, 0);
3761 ipw_write32(priv, write, 0);
3762
3763 _ipw_read32(priv, 0x90);
3764 }
3765
3766 static int ipw_queue_tx_init(struct ipw_priv *priv,
3767 struct clx2_tx_queue *q,
3768 int count, u32 read, u32 write, u32 base, u32 size)
3769 {
3770 struct pci_dev *dev = priv->pci_dev;
3771
3772 q->txb = kmalloc_array(count, sizeof(q->txb[0]), GFP_KERNEL);
3773 if (!q->txb) {
3774 IPW_ERROR("vmalloc for auxiliary BD structures failed\n");
3775 return -ENOMEM;
3776 }
3777
3778 q->bd =
3779 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3780 if (!q->bd) {
3781 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3782 sizeof(q->bd[0]) * count);
3783 kfree(q->txb);
3784 q->txb = NULL;
3785 return -ENOMEM;
3786 }
3787
3788 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3789 return 0;
3790 }
3791
3792
3793
3794
3795
3796
3797
3798
3799 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3800 struct clx2_tx_queue *txq)
3801 {
3802 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3803 struct pci_dev *dev = priv->pci_dev;
3804 int i;
3805
3806
3807 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3808
3809 return;
3810
3811
3812 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3813 IPW_ERROR("Too many chunks: %i\n",
3814 le32_to_cpu(bd->u.data.num_chunks));
3815
3816 return;
3817 }
3818
3819
3820 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3821 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3822 le16_to_cpu(bd->u.data.chunk_len[i]),
3823 PCI_DMA_TODEVICE);
3824 if (txq->txb[txq->q.last_used]) {
3825 libipw_txb_free(txq->txb[txq->q.last_used]);
3826 txq->txb[txq->q.last_used] = NULL;
3827 }
3828 }
3829 }
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3841 {
3842 struct clx2_queue *q = &txq->q;
3843 struct pci_dev *dev = priv->pci_dev;
3844
3845 if (q->n_bd == 0)
3846 return;
3847
3848
3849 for (; q->first_empty != q->last_used;
3850 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3851 ipw_queue_tx_free_tfd(priv, txq);
3852 }
3853
3854
3855 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3856 q->dma_addr);
3857 kfree(txq->txb);
3858
3859
3860 memset(txq, 0, sizeof(*txq));
3861 }
3862
3863
3864
3865
3866
3867
3868 static void ipw_tx_queue_free(struct ipw_priv *priv)
3869 {
3870
3871 ipw_queue_tx_free(priv, &priv->txq_cmd);
3872
3873
3874 ipw_queue_tx_free(priv, &priv->txq[0]);
3875 ipw_queue_tx_free(priv, &priv->txq[1]);
3876 ipw_queue_tx_free(priv, &priv->txq[2]);
3877 ipw_queue_tx_free(priv, &priv->txq[3]);
3878 }
3879
3880 static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3881 {
3882
3883 bssid[0] = priv->mac_addr[0];
3884 bssid[1] = priv->mac_addr[1];
3885 bssid[2] = priv->mac_addr[2];
3886
3887
3888 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3889
3890 bssid[0] &= 0xfe;
3891 bssid[0] |= 0x02;
3892 }
3893
3894 static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3895 {
3896 struct ipw_station_entry entry;
3897 int i;
3898
3899 for (i = 0; i < priv->num_stations; i++) {
3900 if (ether_addr_equal(priv->stations[i], bssid)) {
3901
3902 priv->missed_adhoc_beacons = 0;
3903 if (!(priv->config & CFG_STATIC_CHANNEL))
3904
3905 priv->config &= ~CFG_ADHOC_PERSIST;
3906
3907 return i;
3908 }
3909 }
3910
3911 if (i == MAX_STATIONS)
3912 return IPW_INVALID_STATION;
3913
3914 IPW_DEBUG_SCAN("Adding AdHoc station: %pM\n", bssid);
3915
3916 entry.reserved = 0;
3917 entry.support_mode = 0;
3918 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3919 memcpy(priv->stations[i], bssid, ETH_ALEN);
3920 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3921 &entry, sizeof(entry));
3922 priv->num_stations++;
3923
3924 return i;
3925 }
3926
3927 static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3928 {
3929 int i;
3930
3931 for (i = 0; i < priv->num_stations; i++)
3932 if (ether_addr_equal(priv->stations[i], bssid))
3933 return i;
3934
3935 return IPW_INVALID_STATION;
3936 }
3937
3938 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3939 {
3940 int err;
3941
3942 if (priv->status & STATUS_ASSOCIATING) {
3943 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3944 schedule_work(&priv->disassociate);
3945 return;
3946 }
3947
3948 if (!(priv->status & STATUS_ASSOCIATED)) {
3949 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3950 return;
3951 }
3952
3953 IPW_DEBUG_ASSOC("Disassociation attempt from %pM "
3954 "on channel %d.\n",
3955 priv->assoc_request.bssid,
3956 priv->assoc_request.channel);
3957
3958 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3959 priv->status |= STATUS_DISASSOCIATING;
3960
3961 if (quiet)
3962 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3963 else
3964 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3965
3966 err = ipw_send_associate(priv, &priv->assoc_request);
3967 if (err) {
3968 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3969 "failed.\n");
3970 return;
3971 }
3972
3973 }
3974
3975 static int ipw_disassociate(void *data)
3976 {
3977 struct ipw_priv *priv = data;
3978 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3979 return 0;
3980 ipw_send_disassociate(data, 0);
3981 netif_carrier_off(priv->net_dev);
3982 return 1;
3983 }
3984
3985 static void ipw_bg_disassociate(struct work_struct *work)
3986 {
3987 struct ipw_priv *priv =
3988 container_of(work, struct ipw_priv, disassociate);
3989 mutex_lock(&priv->mutex);
3990 ipw_disassociate(priv);
3991 mutex_unlock(&priv->mutex);
3992 }
3993
3994 static void ipw_system_config(struct work_struct *work)
3995 {
3996 struct ipw_priv *priv =
3997 container_of(work, struct ipw_priv, system_config);
3998
3999 #ifdef CONFIG_IPW2200_PROMISCUOUS
4000 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
4001 priv->sys_config.accept_all_data_frames = 1;
4002 priv->sys_config.accept_non_directed_frames = 1;
4003 priv->sys_config.accept_all_mgmt_bcpr = 1;
4004 priv->sys_config.accept_all_mgmt_frames = 1;
4005 }
4006 #endif
4007
4008 ipw_send_system_config(priv);
4009 }
4010
4011 struct ipw_status_code {
4012 u16 status;
4013 const char *reason;
4014 };
4015
4016 static const struct ipw_status_code ipw_status_codes[] = {
4017 {0x00, "Successful"},
4018 {0x01, "Unspecified failure"},
4019 {0x0A, "Cannot support all requested capabilities in the "
4020 "Capability information field"},
4021 {0x0B, "Reassociation denied due to inability to confirm that "
4022 "association exists"},
4023 {0x0C, "Association denied due to reason outside the scope of this "
4024 "standard"},
4025 {0x0D,
4026 "Responding station does not support the specified authentication "
4027 "algorithm"},
4028 {0x0E,
4029 "Received an Authentication frame with authentication sequence "
4030 "transaction sequence number out of expected sequence"},
4031 {0x0F, "Authentication rejected because of challenge failure"},
4032 {0x10, "Authentication rejected due to timeout waiting for next "
4033 "frame in sequence"},
4034 {0x11, "Association denied because AP is unable to handle additional "
4035 "associated stations"},
4036 {0x12,
4037 "Association denied due to requesting station not supporting all "
4038 "of the datarates in the BSSBasicServiceSet Parameter"},
4039 {0x13,
4040 "Association denied due to requesting station not supporting "
4041 "short preamble operation"},
4042 {0x14,
4043 "Association denied due to requesting station not supporting "
4044 "PBCC encoding"},
4045 {0x15,
4046 "Association denied due to requesting station not supporting "
4047 "channel agility"},
4048 {0x19,
4049 "Association denied due to requesting station not supporting "
4050 "short slot operation"},
4051 {0x1A,
4052 "Association denied due to requesting station not supporting "
4053 "DSSS-OFDM operation"},
4054 {0x28, "Invalid Information Element"},
4055 {0x29, "Group Cipher is not valid"},
4056 {0x2A, "Pairwise Cipher is not valid"},
4057 {0x2B, "AKMP is not valid"},
4058 {0x2C, "Unsupported RSN IE version"},
4059 {0x2D, "Invalid RSN IE Capabilities"},
4060 {0x2E, "Cipher suite is rejected per security policy"},
4061 };
4062
4063 static const char *ipw_get_status_code(u16 status)
4064 {
4065 int i;
4066 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
4067 if (ipw_status_codes[i].status == (status & 0xff))
4068 return ipw_status_codes[i].reason;
4069 return "Unknown status value.";
4070 }
4071
4072 static inline void average_init(struct average *avg)
4073 {
4074 memset(avg, 0, sizeof(*avg));
4075 }
4076
4077 #define DEPTH_RSSI 8
4078 #define DEPTH_NOISE 16
4079 static s16 exponential_average(s16 prev_avg, s16 val, u8 depth)
4080 {
4081 return ((depth-1)*prev_avg + val)/depth;
4082 }
4083
4084 static void average_add(struct average *avg, s16 val)
4085 {
4086 avg->sum -= avg->entries[avg->pos];
4087 avg->sum += val;
4088 avg->entries[avg->pos++] = val;
4089 if (unlikely(avg->pos == AVG_ENTRIES)) {
4090 avg->init = 1;
4091 avg->pos = 0;
4092 }
4093 }
4094
4095 static s16 average_value(struct average *avg)
4096 {
4097 if (!unlikely(avg->init)) {
4098 if (avg->pos)
4099 return avg->sum / avg->pos;
4100 return 0;
4101 }
4102
4103 return avg->sum / AVG_ENTRIES;
4104 }
4105
4106 static void ipw_reset_stats(struct ipw_priv *priv)
4107 {
4108 u32 len = sizeof(u32);
4109
4110 priv->quality = 0;
4111
4112 average_init(&priv->average_missed_beacons);
4113 priv->exp_avg_rssi = -60;
4114 priv->exp_avg_noise = -85 + 0x100;
4115
4116 priv->last_rate = 0;
4117 priv->last_missed_beacons = 0;
4118 priv->last_rx_packets = 0;
4119 priv->last_tx_packets = 0;
4120 priv->last_tx_failures = 0;
4121
4122
4123
4124 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
4125 &priv->last_rx_err, &len);
4126 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
4127 &priv->last_tx_failures, &len);
4128
4129
4130 priv->missed_adhoc_beacons = 0;
4131 priv->missed_beacons = 0;
4132 priv->tx_packets = 0;
4133 priv->rx_packets = 0;
4134
4135 }
4136
4137 static u32 ipw_get_max_rate(struct ipw_priv *priv)
4138 {
4139 u32 i = 0x80000000;
4140 u32 mask = priv->rates_mask;
4141
4142
4143 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
4144 mask &= LIBIPW_CCK_RATES_MASK;
4145
4146
4147
4148
4149 while (i && !(mask & i))
4150 i >>= 1;
4151 switch (i) {
4152 case LIBIPW_CCK_RATE_1MB_MASK:
4153 return 1000000;
4154 case LIBIPW_CCK_RATE_2MB_MASK:
4155 return 2000000;
4156 case LIBIPW_CCK_RATE_5MB_MASK:
4157 return 5500000;
4158 case LIBIPW_OFDM_RATE_6MB_MASK:
4159 return 6000000;
4160 case LIBIPW_OFDM_RATE_9MB_MASK:
4161 return 9000000;
4162 case LIBIPW_CCK_RATE_11MB_MASK:
4163 return 11000000;
4164 case LIBIPW_OFDM_RATE_12MB_MASK:
4165 return 12000000;
4166 case LIBIPW_OFDM_RATE_18MB_MASK:
4167 return 18000000;
4168 case LIBIPW_OFDM_RATE_24MB_MASK:
4169 return 24000000;
4170 case LIBIPW_OFDM_RATE_36MB_MASK:
4171 return 36000000;
4172 case LIBIPW_OFDM_RATE_48MB_MASK:
4173 return 48000000;
4174 case LIBIPW_OFDM_RATE_54MB_MASK:
4175 return 54000000;
4176 }
4177
4178 if (priv->ieee->mode == IEEE_B)
4179 return 11000000;
4180 else
4181 return 54000000;
4182 }
4183
4184 static u32 ipw_get_current_rate(struct ipw_priv *priv)
4185 {
4186 u32 rate, len = sizeof(rate);
4187 int err;
4188
4189 if (!(priv->status & STATUS_ASSOCIATED))
4190 return 0;
4191
4192 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
4193 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
4194 &len);
4195 if (err) {
4196 IPW_DEBUG_INFO("failed querying ordinals.\n");
4197 return 0;
4198 }
4199 } else
4200 return ipw_get_max_rate(priv);
4201
4202 switch (rate) {
4203 case IPW_TX_RATE_1MB:
4204 return 1000000;
4205 case IPW_TX_RATE_2MB:
4206 return 2000000;
4207 case IPW_TX_RATE_5MB:
4208 return 5500000;
4209 case IPW_TX_RATE_6MB:
4210 return 6000000;
4211 case IPW_TX_RATE_9MB:
4212 return 9000000;
4213 case IPW_TX_RATE_11MB:
4214 return 11000000;
4215 case IPW_TX_RATE_12MB:
4216 return 12000000;
4217 case IPW_TX_RATE_18MB:
4218 return 18000000;
4219 case IPW_TX_RATE_24MB:
4220 return 24000000;
4221 case IPW_TX_RATE_36MB:
4222 return 36000000;
4223 case IPW_TX_RATE_48MB:
4224 return 48000000;
4225 case IPW_TX_RATE_54MB:
4226 return 54000000;
4227 }
4228
4229 return 0;
4230 }
4231
4232 #define IPW_STATS_INTERVAL (2 * HZ)
4233 static void ipw_gather_stats(struct ipw_priv *priv)
4234 {
4235 u32 rx_err, rx_err_delta, rx_packets_delta;
4236 u32 tx_failures, tx_failures_delta, tx_packets_delta;
4237 u32 missed_beacons_percent, missed_beacons_delta;
4238 u32 quality = 0;
4239 u32 len = sizeof(u32);
4240 s16 rssi;
4241 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
4242 rate_quality;
4243 u32 max_rate;
4244
4245 if (!(priv->status & STATUS_ASSOCIATED)) {
4246 priv->quality = 0;
4247 return;
4248 }
4249
4250
4251 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
4252 &priv->missed_beacons, &len);
4253 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
4254 priv->last_missed_beacons = priv->missed_beacons;
4255 if (priv->assoc_request.beacon_interval) {
4256 missed_beacons_percent = missed_beacons_delta *
4257 (HZ * le16_to_cpu(priv->assoc_request.beacon_interval)) /
4258 (IPW_STATS_INTERVAL * 10);
4259 } else {
4260 missed_beacons_percent = 0;
4261 }
4262 average_add(&priv->average_missed_beacons, missed_beacons_percent);
4263
4264 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
4265 rx_err_delta = rx_err - priv->last_rx_err;
4266 priv->last_rx_err = rx_err;
4267
4268 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
4269 tx_failures_delta = tx_failures - priv->last_tx_failures;
4270 priv->last_tx_failures = tx_failures;
4271
4272 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4273 priv->last_rx_packets = priv->rx_packets;
4274
4275 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4276 priv->last_tx_packets = priv->tx_packets;
4277
4278
4279
4280
4281
4282
4283
4284
4285
4286
4287
4288
4289 #define BEACON_THRESHOLD 5
4290 beacon_quality = 100 - missed_beacons_percent;
4291 if (beacon_quality < BEACON_THRESHOLD)
4292 beacon_quality = 0;
4293 else
4294 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4295 (100 - BEACON_THRESHOLD);
4296 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4297 beacon_quality, missed_beacons_percent);
4298
4299 priv->last_rate = ipw_get_current_rate(priv);
4300 max_rate = ipw_get_max_rate(priv);
4301 rate_quality = priv->last_rate * 40 / max_rate + 60;
4302 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4303 rate_quality, priv->last_rate / 1000000);
4304
4305 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4306 rx_quality = 100 - (rx_err_delta * 100) /
4307 (rx_packets_delta + rx_err_delta);
4308 else
4309 rx_quality = 100;
4310 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4311 rx_quality, rx_err_delta, rx_packets_delta);
4312
4313 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4314 tx_quality = 100 - (tx_failures_delta * 100) /
4315 (tx_packets_delta + tx_failures_delta);
4316 else
4317 tx_quality = 100;
4318 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4319 tx_quality, tx_failures_delta, tx_packets_delta);
4320
4321 rssi = priv->exp_avg_rssi;
4322 signal_quality =
4323 (100 *
4324 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4325 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4326 (priv->ieee->perfect_rssi - rssi) *
4327 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4328 62 * (priv->ieee->perfect_rssi - rssi))) /
4329 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4330 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4331 if (signal_quality > 100)
4332 signal_quality = 100;
4333 else if (signal_quality < 1)
4334 signal_quality = 0;
4335
4336 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4337 signal_quality, rssi);
4338
4339 quality = min(rx_quality, signal_quality);
4340 quality = min(tx_quality, quality);
4341 quality = min(rate_quality, quality);
4342 quality = min(beacon_quality, quality);
4343 if (quality == beacon_quality)
4344 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4345 quality);
4346 if (quality == rate_quality)
4347 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4348 quality);
4349 if (quality == tx_quality)
4350 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4351 quality);
4352 if (quality == rx_quality)
4353 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4354 quality);
4355 if (quality == signal_quality)
4356 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4357 quality);
4358
4359 priv->quality = quality;
4360
4361 schedule_delayed_work(&priv->gather_stats, IPW_STATS_INTERVAL);
4362 }
4363
4364 static void ipw_bg_gather_stats(struct work_struct *work)
4365 {
4366 struct ipw_priv *priv =
4367 container_of(work, struct ipw_priv, gather_stats.work);
4368 mutex_lock(&priv->mutex);
4369 ipw_gather_stats(priv);
4370 mutex_unlock(&priv->mutex);
4371 }
4372
4373
4374
4375
4376
4377
4378 static void ipw_handle_missed_beacon(struct ipw_priv *priv,
4379 int missed_count)
4380 {
4381 priv->notif_missed_beacons = missed_count;
4382
4383 if (missed_count > priv->disassociate_threshold &&
4384 priv->status & STATUS_ASSOCIATED) {
4385
4386
4387
4388 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4389 IPW_DL_STATE | IPW_DL_ASSOC,
4390 "Missed beacon: %d - disassociate\n", missed_count);
4391 priv->status &= ~STATUS_ROAMING;
4392 if (priv->status & STATUS_SCANNING) {
4393 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4394 IPW_DL_STATE,
4395 "Aborting scan with missed beacon.\n");
4396 schedule_work(&priv->abort_scan);
4397 }
4398
4399 schedule_work(&priv->disassociate);
4400 return;
4401 }
4402
4403 if (priv->status & STATUS_ROAMING) {
4404
4405
4406 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4407 "Missed beacon: %d - roam in progress\n",
4408 missed_count);
4409 return;
4410 }
4411
4412 if (roaming &&
4413 (missed_count > priv->roaming_threshold &&
4414 missed_count <= priv->disassociate_threshold)) {
4415
4416
4417
4418
4419 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4420 "Missed beacon: %d - initiate "
4421 "roaming\n", missed_count);
4422 if (!(priv->status & STATUS_ROAMING)) {
4423 priv->status |= STATUS_ROAMING;
4424 if (!(priv->status & STATUS_SCANNING))
4425 schedule_delayed_work(&priv->request_scan, 0);
4426 }
4427 return;
4428 }
4429
4430 if (priv->status & STATUS_SCANNING &&
4431 missed_count > IPW_MB_SCAN_CANCEL_THRESHOLD) {
4432
4433
4434
4435
4436 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4437 "Aborting scan with missed beacon.\n");
4438 schedule_work(&priv->abort_scan);
4439 }
4440
4441 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4442 }
4443
4444 static void ipw_scan_event(struct work_struct *work)
4445 {
4446 union iwreq_data wrqu;
4447
4448 struct ipw_priv *priv =
4449 container_of(work, struct ipw_priv, scan_event.work);
4450
4451 wrqu.data.length = 0;
4452 wrqu.data.flags = 0;
4453 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4454 }
4455
4456 static void handle_scan_event(struct ipw_priv *priv)
4457 {
4458
4459 if (!priv->user_requested_scan) {
4460 schedule_delayed_work(&priv->scan_event,
4461 round_jiffies_relative(msecs_to_jiffies(4000)));
4462 } else {
4463 priv->user_requested_scan = 0;
4464 mod_delayed_work(system_wq, &priv->scan_event, 0);
4465 }
4466 }
4467
4468
4469
4470
4471
4472 static void ipw_rx_notification(struct ipw_priv *priv,
4473 struct ipw_rx_notification *notif)
4474 {
4475 u16 size = le16_to_cpu(notif->size);
4476
4477 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, size);
4478
4479 switch (notif->subtype) {
4480 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4481 struct notif_association *assoc = ¬if->u.assoc;
4482
4483 switch (assoc->state) {
4484 case CMAS_ASSOCIATED:{
4485 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4486 IPW_DL_ASSOC,
4487 "associated: '%*pE' %pM\n",
4488 priv->essid_len, priv->essid,
4489 priv->bssid);
4490
4491 switch (priv->ieee->iw_mode) {
4492 case IW_MODE_INFRA:
4493 memcpy(priv->ieee->bssid,
4494 priv->bssid, ETH_ALEN);
4495 break;
4496
4497 case IW_MODE_ADHOC:
4498 memcpy(priv->ieee->bssid,
4499 priv->bssid, ETH_ALEN);
4500
4501
4502 priv->num_stations = 0;
4503
4504 IPW_DEBUG_ASSOC
4505 ("queueing adhoc check\n");
4506 schedule_delayed_work(
4507 &priv->adhoc_check,
4508 le16_to_cpu(priv->
4509 assoc_request.
4510 beacon_interval));
4511 break;
4512 }
4513
4514 priv->status &= ~STATUS_ASSOCIATING;
4515 priv->status |= STATUS_ASSOCIATED;
4516 schedule_work(&priv->system_config);
4517
4518 #ifdef CONFIG_IPW2200_QOS
4519 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4520 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_control))
4521 if ((priv->status & STATUS_AUTH) &&
4522 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4523 == IEEE80211_STYPE_ASSOC_RESP)) {
4524 if ((sizeof
4525 (struct
4526 libipw_assoc_response)
4527 <= size)
4528 && (size <= 2314)) {
4529 struct
4530 libipw_rx_stats
4531 stats = {
4532 .len = size - 1,
4533 };
4534
4535 IPW_DEBUG_QOS
4536 ("QoS Associate "
4537 "size %d\n", size);
4538 libipw_rx_mgt(priv->
4539 ieee,
4540 (struct
4541 libipw_hdr_4addr
4542 *)
4543 ¬if->u.raw, &stats);
4544 }
4545 }
4546 #endif
4547
4548 schedule_work(&priv->link_up);
4549
4550 break;
4551 }
4552
4553 case CMAS_AUTHENTICATED:{
4554 if (priv->
4555 status & (STATUS_ASSOCIATED |
4556 STATUS_AUTH)) {
4557 struct notif_authenticate *auth
4558 = ¬if->u.auth;
4559 IPW_DEBUG(IPW_DL_NOTIF |
4560 IPW_DL_STATE |
4561 IPW_DL_ASSOC,
4562 "deauthenticated: '%*pE' %pM: (0x%04X) - %s\n",
4563 priv->essid_len,
4564 priv->essid,
4565 priv->bssid,
4566 le16_to_cpu(auth->status),
4567 ipw_get_status_code
4568 (le16_to_cpu
4569 (auth->status)));
4570
4571 priv->status &=
4572 ~(STATUS_ASSOCIATING |
4573 STATUS_AUTH |
4574 STATUS_ASSOCIATED);
4575
4576 schedule_work(&priv->link_down);
4577 break;
4578 }
4579
4580 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4581 IPW_DL_ASSOC,
4582 "authenticated: '%*pE' %pM\n",
4583 priv->essid_len, priv->essid,
4584 priv->bssid);
4585 break;
4586 }
4587
4588 case CMAS_INIT:{
4589 if (priv->status & STATUS_AUTH) {
4590 struct
4591 libipw_assoc_response
4592 *resp;
4593 resp =
4594 (struct
4595 libipw_assoc_response
4596 *)¬if->u.raw;
4597 IPW_DEBUG(IPW_DL_NOTIF |
4598 IPW_DL_STATE |
4599 IPW_DL_ASSOC,
4600 "association failed (0x%04X): %s\n",
4601 le16_to_cpu(resp->status),
4602 ipw_get_status_code
4603 (le16_to_cpu
4604 (resp->status)));
4605 }
4606
4607 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4608 IPW_DL_ASSOC,
4609 "disassociated: '%*pE' %pM\n",
4610 priv->essid_len, priv->essid,
4611 priv->bssid);
4612
4613 priv->status &=
4614 ~(STATUS_DISASSOCIATING |
4615 STATUS_ASSOCIATING |
4616 STATUS_ASSOCIATED | STATUS_AUTH);
4617 if (priv->assoc_network
4618 && (priv->assoc_network->
4619 capability &
4620 WLAN_CAPABILITY_IBSS))
4621 ipw_remove_current_network
4622 (priv);
4623
4624 schedule_work(&priv->link_down);
4625
4626 break;
4627 }
4628
4629 case CMAS_RX_ASSOC_RESP:
4630 break;
4631
4632 default:
4633 IPW_ERROR("assoc: unknown (%d)\n",
4634 assoc->state);
4635 break;
4636 }
4637
4638 break;
4639 }
4640
4641 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4642 struct notif_authenticate *auth = ¬if->u.auth;
4643 switch (auth->state) {
4644 case CMAS_AUTHENTICATED:
4645 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4646 "authenticated: '%*pE' %pM\n",
4647 priv->essid_len, priv->essid,
4648 priv->bssid);
4649 priv->status |= STATUS_AUTH;
4650 break;
4651
4652 case CMAS_INIT:
4653 if (priv->status & STATUS_AUTH) {
4654 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4655 IPW_DL_ASSOC,
4656 "authentication failed (0x%04X): %s\n",
4657 le16_to_cpu(auth->status),
4658 ipw_get_status_code(le16_to_cpu
4659 (auth->
4660 status)));
4661 }
4662 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4663 IPW_DL_ASSOC,
4664 "deauthenticated: '%*pE' %pM\n",
4665 priv->essid_len, priv->essid,
4666 priv->bssid);
4667
4668 priv->status &= ~(STATUS_ASSOCIATING |
4669 STATUS_AUTH |
4670 STATUS_ASSOCIATED);
4671
4672 schedule_work(&priv->link_down);
4673 break;
4674
4675 case CMAS_TX_AUTH_SEQ_1:
4676 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4677 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4678 break;
4679 case CMAS_RX_AUTH_SEQ_2:
4680 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4681 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4682 break;
4683 case CMAS_AUTH_SEQ_1_PASS:
4684 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4685 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4686 break;
4687 case CMAS_AUTH_SEQ_1_FAIL:
4688 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4689 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4690 break;
4691 case CMAS_TX_AUTH_SEQ_3:
4692 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4693 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4694 break;
4695 case CMAS_RX_AUTH_SEQ_4:
4696 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4697 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4698 break;
4699 case CMAS_AUTH_SEQ_2_PASS:
4700 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4701 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4702 break;
4703 case CMAS_AUTH_SEQ_2_FAIL:
4704 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4705 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4706 break;
4707 case CMAS_TX_ASSOC:
4708 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4709 IPW_DL_ASSOC, "TX_ASSOC\n");
4710 break;
4711 case CMAS_RX_ASSOC_RESP:
4712 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4713 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4714
4715 break;
4716 case CMAS_ASSOCIATED:
4717 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4718 IPW_DL_ASSOC, "ASSOCIATED\n");
4719 break;
4720 default:
4721 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4722 auth->state);
4723 break;
4724 }
4725 break;
4726 }
4727
4728 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4729 struct notif_channel_result *x =
4730 ¬if->u.channel_result;
4731
4732 if (size == sizeof(*x)) {
4733 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4734 x->channel_num);
4735 } else {
4736 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4737 "(should be %zd)\n",
4738 size, sizeof(*x));
4739 }
4740 break;
4741 }
4742
4743 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4744 struct notif_scan_complete *x = ¬if->u.scan_complete;
4745 if (size == sizeof(*x)) {
4746 IPW_DEBUG_SCAN
4747 ("Scan completed: type %d, %d channels, "
4748 "%d status\n", x->scan_type,
4749 x->num_channels, x->status);
4750 } else {
4751 IPW_ERROR("Scan completed of wrong size %d "
4752 "(should be %zd)\n",
4753 size, sizeof(*x));
4754 }
4755
4756 priv->status &=
4757 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4758
4759 wake_up_interruptible(&priv->wait_state);
4760 cancel_delayed_work(&priv->scan_check);
4761
4762 if (priv->status & STATUS_EXIT_PENDING)
4763 break;
4764
4765 priv->ieee->scans++;
4766
4767 #ifdef CONFIG_IPW2200_MONITOR
4768 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4769 priv->status |= STATUS_SCAN_FORCED;
4770 schedule_delayed_work(&priv->request_scan, 0);
4771 break;
4772 }
4773 priv->status &= ~STATUS_SCAN_FORCED;
4774 #endif
4775
4776
4777 if (priv->status & STATUS_DIRECT_SCAN_PENDING)
4778 schedule_delayed_work(&priv->request_direct_scan, 0);
4779
4780 if (!(priv->status & (STATUS_ASSOCIATED |
4781 STATUS_ASSOCIATING |
4782 STATUS_ROAMING |
4783 STATUS_DISASSOCIATING)))
4784 schedule_work(&priv->associate);
4785 else if (priv->status & STATUS_ROAMING) {
4786 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4787
4788
4789
4790
4791 schedule_work(&priv->roam);
4792 else
4793
4794 priv->status &= ~STATUS_ROAMING;
4795 } else if (priv->status & STATUS_SCAN_PENDING)
4796 schedule_delayed_work(&priv->request_scan, 0);
4797 else if (priv->config & CFG_BACKGROUND_SCAN
4798 && priv->status & STATUS_ASSOCIATED)
4799 schedule_delayed_work(&priv->request_scan,
4800 round_jiffies_relative(HZ));
4801
4802
4803
4804
4805
4806
4807
4808
4809
4810
4811 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4812 handle_scan_event(priv);
4813 break;
4814 }
4815
4816 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4817 struct notif_frag_length *x = ¬if->u.frag_len;
4818
4819 if (size == sizeof(*x))
4820 IPW_ERROR("Frag length: %d\n",
4821 le16_to_cpu(x->frag_length));
4822 else
4823 IPW_ERROR("Frag length of wrong size %d "
4824 "(should be %zd)\n",
4825 size, sizeof(*x));
4826 break;
4827 }
4828
4829 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4830 struct notif_link_deterioration *x =
4831 ¬if->u.link_deterioration;
4832
4833 if (size == sizeof(*x)) {
4834 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4835 "link deterioration: type %d, cnt %d\n",
4836 x->silence_notification_type,
4837 x->silence_count);
4838 memcpy(&priv->last_link_deterioration, x,
4839 sizeof(*x));
4840 } else {
4841 IPW_ERROR("Link Deterioration of wrong size %d "
4842 "(should be %zd)\n",
4843 size, sizeof(*x));
4844 }
4845 break;
4846 }
4847
4848 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4849 IPW_ERROR("Dino config\n");
4850 if (priv->hcmd
4851 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4852 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4853
4854 break;
4855 }
4856
4857 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4858 struct notif_beacon_state *x = ¬if->u.beacon_state;
4859 if (size != sizeof(*x)) {
4860 IPW_ERROR
4861 ("Beacon state of wrong size %d (should "
4862 "be %zd)\n", size, sizeof(*x));
4863 break;
4864 }
4865
4866 if (le32_to_cpu(x->state) ==
4867 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4868 ipw_handle_missed_beacon(priv,
4869 le32_to_cpu(x->
4870 number));
4871
4872 break;
4873 }
4874
4875 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4876 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4877 if (size == sizeof(*x)) {
4878 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4879 "0x%02x station %d\n",
4880 x->key_state, x->security_type,
4881 x->station_index);
4882 break;
4883 }
4884
4885 IPW_ERROR
4886 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4887 size, sizeof(*x));
4888 break;
4889 }
4890
4891 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4892 struct notif_calibration *x = ¬if->u.calibration;
4893
4894 if (size == sizeof(*x)) {
4895 memcpy(&priv->calib, x, sizeof(*x));
4896 IPW_DEBUG_INFO("TODO: Calibration\n");
4897 break;
4898 }
4899
4900 IPW_ERROR
4901 ("Calibration of wrong size %d (should be %zd)\n",
4902 size, sizeof(*x));
4903 break;
4904 }
4905
4906 case HOST_NOTIFICATION_NOISE_STATS:{
4907 if (size == sizeof(u32)) {
4908 priv->exp_avg_noise =
4909 exponential_average(priv->exp_avg_noise,
4910 (u8) (le32_to_cpu(notif->u.noise.value) & 0xff),
4911 DEPTH_NOISE);
4912 break;
4913 }
4914
4915 IPW_ERROR
4916 ("Noise stat is wrong size %d (should be %zd)\n",
4917 size, sizeof(u32));
4918 break;
4919 }
4920
4921 default:
4922 IPW_DEBUG_NOTIF("Unknown notification: "
4923 "subtype=%d,flags=0x%2x,size=%d\n",
4924 notif->subtype, notif->flags, size);
4925 }
4926 }
4927
4928
4929
4930
4931
4932
4933
4934 static int ipw_queue_reset(struct ipw_priv *priv)
4935 {
4936 int rc = 0;
4937
4938 int nTx = 64, nTxCmd = 8;
4939 ipw_tx_queue_free(priv);
4940
4941 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4942 IPW_TX_CMD_QUEUE_READ_INDEX,
4943 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4944 IPW_TX_CMD_QUEUE_BD_BASE,
4945 IPW_TX_CMD_QUEUE_BD_SIZE);
4946 if (rc) {
4947 IPW_ERROR("Tx Cmd queue init failed\n");
4948 goto error;
4949 }
4950
4951 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4952 IPW_TX_QUEUE_0_READ_INDEX,
4953 IPW_TX_QUEUE_0_WRITE_INDEX,
4954 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4955 if (rc) {
4956 IPW_ERROR("Tx 0 queue init failed\n");
4957 goto error;
4958 }
4959 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4960 IPW_TX_QUEUE_1_READ_INDEX,
4961 IPW_TX_QUEUE_1_WRITE_INDEX,
4962 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4963 if (rc) {
4964 IPW_ERROR("Tx 1 queue init failed\n");
4965 goto error;
4966 }
4967 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4968 IPW_TX_QUEUE_2_READ_INDEX,
4969 IPW_TX_QUEUE_2_WRITE_INDEX,
4970 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4971 if (rc) {
4972 IPW_ERROR("Tx 2 queue init failed\n");
4973 goto error;
4974 }
4975 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4976 IPW_TX_QUEUE_3_READ_INDEX,
4977 IPW_TX_QUEUE_3_WRITE_INDEX,
4978 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4979 if (rc) {
4980 IPW_ERROR("Tx 3 queue init failed\n");
4981 goto error;
4982 }
4983
4984 priv->rx_bufs_min = 0;
4985 priv->rx_pend_max = 0;
4986 return rc;
4987
4988 error:
4989 ipw_tx_queue_free(priv);
4990 return rc;
4991 }
4992
4993
4994
4995
4996
4997
4998
4999
5000
5001
5002
5003
5004
5005
5006 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
5007 struct clx2_tx_queue *txq, int qindex)
5008 {
5009 u32 hw_tail;
5010 int used;
5011 struct clx2_queue *q = &txq->q;
5012
5013 hw_tail = ipw_read32(priv, q->reg_r);
5014 if (hw_tail >= q->n_bd) {
5015 IPW_ERROR
5016 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
5017 hw_tail, q->n_bd);
5018 goto done;
5019 }
5020 for (; q->last_used != hw_tail;
5021 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
5022 ipw_queue_tx_free_tfd(priv, txq);
5023 priv->tx_packets++;
5024 }
5025 done:
5026 if ((ipw_tx_queue_space(q) > q->low_mark) &&
5027 (qindex >= 0))
5028 netif_wake_queue(priv->net_dev);
5029 used = q->first_empty - q->last_used;
5030 if (used < 0)
5031 used += q->n_bd;
5032
5033 return used;
5034 }
5035
5036 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
5037 int len, int sync)
5038 {
5039 struct clx2_tx_queue *txq = &priv->txq_cmd;
5040 struct clx2_queue *q = &txq->q;
5041 struct tfd_frame *tfd;
5042
5043 if (ipw_tx_queue_space(q) < (sync ? 1 : 2)) {
5044 IPW_ERROR("No space for Tx\n");
5045 return -EBUSY;
5046 }
5047
5048 tfd = &txq->bd[q->first_empty];
5049 txq->txb[q->first_empty] = NULL;
5050
5051 memset(tfd, 0, sizeof(*tfd));
5052 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
5053 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
5054 priv->hcmd_seq++;
5055 tfd->u.cmd.index = hcmd;
5056 tfd->u.cmd.length = len;
5057 memcpy(tfd->u.cmd.payload, buf, len);
5058 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
5059 ipw_write32(priv, q->reg_w, q->first_empty);
5060 _ipw_read32(priv, 0x90);
5061
5062 return 0;
5063 }
5064
5065
5066
5067
5068
5069
5070
5071
5072
5073
5074
5075
5076
5077
5078
5079
5080
5081
5082
5083
5084
5085
5086
5087
5088
5089
5090
5091
5092
5093
5094
5095
5096
5097
5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108
5109
5110
5111
5112
5113
5114
5115
5116
5117
5118
5119
5120
5121
5122
5123
5124
5125
5126
5127
5128
5129
5130
5131
5132
5133
5134
5135
5136
5137
5138 static void ipw_rx_queue_restock(struct ipw_priv *priv)
5139 {
5140 struct ipw_rx_queue *rxq = priv->rxq;
5141 struct list_head *element;
5142 struct ipw_rx_mem_buffer *rxb;
5143 unsigned long flags;
5144 int write;
5145
5146 spin_lock_irqsave(&rxq->lock, flags);
5147 write = rxq->write;
5148 while ((ipw_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
5149 element = rxq->rx_free.next;
5150 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5151 list_del(element);
5152
5153 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
5154 rxb->dma_addr);
5155 rxq->queue[rxq->write] = rxb;
5156 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
5157 rxq->free_count--;
5158 }
5159 spin_unlock_irqrestore(&rxq->lock, flags);
5160
5161
5162
5163 if (rxq->free_count <= RX_LOW_WATERMARK)
5164 schedule_work(&priv->rx_replenish);
5165
5166
5167 if (write != rxq->write)
5168 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
5169 }
5170
5171
5172
5173
5174
5175
5176
5177 static void ipw_rx_queue_replenish(void *data)
5178 {
5179 struct ipw_priv *priv = data;
5180 struct ipw_rx_queue *rxq = priv->rxq;
5181 struct list_head *element;
5182 struct ipw_rx_mem_buffer *rxb;
5183 unsigned long flags;
5184
5185 spin_lock_irqsave(&rxq->lock, flags);
5186 while (!list_empty(&rxq->rx_used)) {
5187 element = rxq->rx_used.next;
5188 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5189 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
5190 if (!rxb->skb) {
5191 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
5192 priv->net_dev->name);
5193
5194
5195
5196 break;
5197 }
5198 list_del(element);
5199
5200 rxb->dma_addr =
5201 pci_map_single(priv->pci_dev, rxb->skb->data,
5202 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
5203
5204 list_add_tail(&rxb->list, &rxq->rx_free);
5205 rxq->free_count++;
5206 }
5207 spin_unlock_irqrestore(&rxq->lock, flags);
5208
5209 ipw_rx_queue_restock(priv);
5210 }
5211
5212 static void ipw_bg_rx_queue_replenish(struct work_struct *work)
5213 {
5214 struct ipw_priv *priv =
5215 container_of(work, struct ipw_priv, rx_replenish);
5216 mutex_lock(&priv->mutex);
5217 ipw_rx_queue_replenish(priv);
5218 mutex_unlock(&priv->mutex);
5219 }
5220
5221
5222
5223
5224
5225
5226 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
5227 {
5228 int i;
5229
5230 if (!rxq)
5231 return;
5232
5233 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
5234 if (rxq->pool[i].skb != NULL) {
5235 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
5236 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
5237 dev_kfree_skb(rxq->pool[i].skb);
5238 }
5239 }
5240
5241 kfree(rxq);
5242 }
5243
5244 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
5245 {
5246 struct ipw_rx_queue *rxq;
5247 int i;
5248
5249 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
5250 if (unlikely(!rxq)) {
5251 IPW_ERROR("memory allocation failed\n");
5252 return NULL;
5253 }
5254 spin_lock_init(&rxq->lock);
5255 INIT_LIST_HEAD(&rxq->rx_free);
5256 INIT_LIST_HEAD(&rxq->rx_used);
5257
5258
5259 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
5260 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
5261
5262
5263
5264 rxq->read = rxq->write = 0;
5265 rxq->free_count = 0;
5266
5267 return rxq;
5268 }
5269
5270 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
5271 {
5272 rate &= ~LIBIPW_BASIC_RATE_MASK;
5273 if (ieee_mode == IEEE_A) {
5274 switch (rate) {
5275 case LIBIPW_OFDM_RATE_6MB:
5276 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ?
5277 1 : 0;
5278 case LIBIPW_OFDM_RATE_9MB:
5279 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ?
5280 1 : 0;
5281 case LIBIPW_OFDM_RATE_12MB:
5282 return priv->
5283 rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5284 case LIBIPW_OFDM_RATE_18MB:
5285 return priv->
5286 rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5287 case LIBIPW_OFDM_RATE_24MB:
5288 return priv->
5289 rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5290 case LIBIPW_OFDM_RATE_36MB:
5291 return priv->
5292 rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5293 case LIBIPW_OFDM_RATE_48MB:
5294 return priv->
5295 rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5296 case LIBIPW_OFDM_RATE_54MB:
5297 return priv->
5298 rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
5299 default:
5300 return 0;
5301 }
5302 }
5303
5304
5305 switch (rate) {
5306 case LIBIPW_CCK_RATE_1MB:
5307 return priv->rates_mask & LIBIPW_CCK_RATE_1MB_MASK ? 1 : 0;
5308 case LIBIPW_CCK_RATE_2MB:
5309 return priv->rates_mask & LIBIPW_CCK_RATE_2MB_MASK ? 1 : 0;
5310 case LIBIPW_CCK_RATE_5MB:
5311 return priv->rates_mask & LIBIPW_CCK_RATE_5MB_MASK ? 1 : 0;
5312 case LIBIPW_CCK_RATE_11MB:
5313 return priv->rates_mask & LIBIPW_CCK_RATE_11MB_MASK ? 1 : 0;
5314 }
5315
5316
5317 if (ieee_mode == IEEE_B)
5318 return 0;
5319
5320
5321 switch (rate) {
5322 case LIBIPW_OFDM_RATE_6MB:
5323 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ? 1 : 0;
5324 case LIBIPW_OFDM_RATE_9MB:
5325 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ? 1 : 0;
5326 case LIBIPW_OFDM_RATE_12MB:
5327 return priv->rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5328 case LIBIPW_OFDM_RATE_18MB:
5329 return priv->rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5330 case LIBIPW_OFDM_RATE_24MB:
5331 return priv->rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5332 case LIBIPW_OFDM_RATE_36MB:
5333 return priv->rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5334 case LIBIPW_OFDM_RATE_48MB:
5335 return priv->rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5336 case LIBIPW_OFDM_RATE_54MB:
5337 return priv->rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
5338 }
5339
5340 return 0;
5341 }
5342
5343 static int ipw_compatible_rates(struct ipw_priv *priv,
5344 const struct libipw_network *network,
5345 struct ipw_supported_rates *rates)
5346 {
5347 int num_rates, i;
5348
5349 memset(rates, 0, sizeof(*rates));
5350 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5351 rates->num_rates = 0;
5352 for (i = 0; i < num_rates; i++) {
5353 if (!ipw_is_rate_in_mask(priv, network->mode,
5354 network->rates[i])) {
5355
5356 if (network->rates[i] & LIBIPW_BASIC_RATE_MASK) {
5357 IPW_DEBUG_SCAN("Adding masked mandatory "
5358 "rate %02X\n",
5359 network->rates[i]);
5360 rates->supported_rates[rates->num_rates++] =
5361 network->rates[i];
5362 continue;
5363 }
5364
5365 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5366 network->rates[i], priv->rates_mask);
5367 continue;
5368 }
5369
5370 rates->supported_rates[rates->num_rates++] = network->rates[i];
5371 }
5372
5373 num_rates = min(network->rates_ex_len,
5374 (u8) (IPW_MAX_RATES - num_rates));
5375 for (i = 0; i < num_rates; i++) {
5376 if (!ipw_is_rate_in_mask(priv, network->mode,
5377 network->rates_ex[i])) {
5378 if (network->rates_ex[i] & LIBIPW_BASIC_RATE_MASK) {
5379 IPW_DEBUG_SCAN("Adding masked mandatory "
5380 "rate %02X\n",
5381 network->rates_ex[i]);
5382 rates->supported_rates[rates->num_rates++] =
5383 network->rates[i];
5384 continue;
5385 }
5386
5387 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5388 network->rates_ex[i], priv->rates_mask);
5389 continue;
5390 }
5391
5392 rates->supported_rates[rates->num_rates++] =
5393 network->rates_ex[i];
5394 }
5395
5396 return 1;
5397 }
5398
5399 static void ipw_copy_rates(struct ipw_supported_rates *dest,
5400 const struct ipw_supported_rates *src)
5401 {
5402 u8 i;
5403 for (i = 0; i < src->num_rates; i++)
5404 dest->supported_rates[i] = src->supported_rates[i];
5405 dest->num_rates = src->num_rates;
5406 }
5407
5408
5409
5410
5411 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5412 u8 modulation, u32 rate_mask)
5413 {
5414 u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5415 LIBIPW_BASIC_RATE_MASK : 0;
5416
5417 if (rate_mask & LIBIPW_CCK_RATE_1MB_MASK)
5418 rates->supported_rates[rates->num_rates++] =
5419 LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_1MB;
5420
5421 if (rate_mask & LIBIPW_CCK_RATE_2MB_MASK)
5422 rates->supported_rates[rates->num_rates++] =
5423 LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_2MB;
5424
5425 if (rate_mask & LIBIPW_CCK_RATE_5MB_MASK)
5426 rates->supported_rates[rates->num_rates++] = basic_mask |
5427 LIBIPW_CCK_RATE_5MB;
5428
5429 if (rate_mask & LIBIPW_CCK_RATE_11MB_MASK)
5430 rates->supported_rates[rates->num_rates++] = basic_mask |
5431 LIBIPW_CCK_RATE_11MB;
5432 }
5433
5434 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5435 u8 modulation, u32 rate_mask)
5436 {
5437 u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5438 LIBIPW_BASIC_RATE_MASK : 0;
5439
5440 if (rate_mask & LIBIPW_OFDM_RATE_6MB_MASK)
5441 rates->supported_rates[rates->num_rates++] = basic_mask |
5442 LIBIPW_OFDM_RATE_6MB;
5443
5444 if (rate_mask & LIBIPW_OFDM_RATE_9MB_MASK)
5445 rates->supported_rates[rates->num_rates++] =
5446 LIBIPW_OFDM_RATE_9MB;
5447
5448 if (rate_mask & LIBIPW_OFDM_RATE_12MB_MASK)
5449 rates->supported_rates[rates->num_rates++] = basic_mask |
5450 LIBIPW_OFDM_RATE_12MB;
5451
5452 if (rate_mask & LIBIPW_OFDM_RATE_18MB_MASK)
5453 rates->supported_rates[rates->num_rates++] =
5454 LIBIPW_OFDM_RATE_18MB;
5455
5456 if (rate_mask & LIBIPW_OFDM_RATE_24MB_MASK)
5457 rates->supported_rates[rates->num_rates++] = basic_mask |
5458 LIBIPW_OFDM_RATE_24MB;
5459
5460 if (rate_mask & LIBIPW_OFDM_RATE_36MB_MASK)
5461 rates->supported_rates[rates->num_rates++] =
5462 LIBIPW_OFDM_RATE_36MB;
5463
5464 if (rate_mask & LIBIPW_OFDM_RATE_48MB_MASK)
5465 rates->supported_rates[rates->num_rates++] =
5466 LIBIPW_OFDM_RATE_48MB;
5467
5468 if (rate_mask & LIBIPW_OFDM_RATE_54MB_MASK)
5469 rates->supported_rates[rates->num_rates++] =
5470 LIBIPW_OFDM_RATE_54MB;
5471 }
5472
5473 struct ipw_network_match {
5474 struct libipw_network *network;
5475 struct ipw_supported_rates rates;
5476 };
5477
5478 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5479 struct ipw_network_match *match,
5480 struct libipw_network *network,
5481 int roaming)
5482 {
5483 struct ipw_supported_rates rates;
5484
5485
5486
5487 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5488 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5489 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded due to capability mismatch.\n",
5490 network->ssid_len, network->ssid,
5491 network->bssid);
5492 return 0;
5493 }
5494
5495 if (unlikely(roaming)) {
5496
5497
5498 if ((network->ssid_len != match->network->ssid_len) ||
5499 memcmp(network->ssid, match->network->ssid,
5500 network->ssid_len)) {
5501 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of non-network ESSID.\n",
5502 network->ssid_len, network->ssid,
5503 network->bssid);
5504 return 0;
5505 }
5506 } else {
5507
5508
5509 if ((priv->config & CFG_STATIC_ESSID) &&
5510 ((network->ssid_len != priv->essid_len) ||
5511 memcmp(network->ssid, priv->essid,
5512 min(network->ssid_len, priv->essid_len)))) {
5513 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of ESSID mismatch: '%*pE'.\n",
5514 network->ssid_len, network->ssid,
5515 network->bssid, priv->essid_len,
5516 priv->essid);
5517 return 0;
5518 }
5519 }
5520
5521
5522
5523
5524 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5525 IPW_DEBUG_MERGE("Network '%*pE excluded because newer than current network.\n",
5526 match->network->ssid_len, match->network->ssid);
5527 return 0;
5528 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5529 IPW_DEBUG_MERGE("Network '%*pE excluded because newer than current network.\n",
5530 match->network->ssid_len, match->network->ssid);
5531 return 0;
5532 }
5533
5534
5535 if (priv->ieee->scan_age != 0 &&
5536 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5537 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of age: %ums.\n",
5538 network->ssid_len, network->ssid,
5539 network->bssid,
5540 jiffies_to_msecs(jiffies -
5541 network->last_scanned));
5542 return 0;
5543 }
5544
5545 if ((priv->config & CFG_STATIC_CHANNEL) &&
5546 (network->channel != priv->channel)) {
5547 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of channel mismatch: %d != %d.\n",
5548 network->ssid_len, network->ssid,
5549 network->bssid,
5550 network->channel, priv->channel);
5551 return 0;
5552 }
5553
5554
5555 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5556 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5557 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of privacy mismatch: %s != %s.\n",
5558 network->ssid_len, network->ssid,
5559 network->bssid,
5560 priv->
5561 capability & CAP_PRIVACY_ON ? "on" : "off",
5562 network->
5563 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5564 "off");
5565 return 0;
5566 }
5567
5568 if (ether_addr_equal(network->bssid, priv->bssid)) {
5569 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of the same BSSID match: %pM.\n",
5570 network->ssid_len, network->ssid,
5571 network->bssid, priv->bssid);
5572 return 0;
5573 }
5574
5575
5576 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5577 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of invalid frequency/mode combination.\n",
5578 network->ssid_len, network->ssid,
5579 network->bssid);
5580 return 0;
5581 }
5582
5583
5584
5585 if (!ipw_compatible_rates(priv, network, &rates)) {
5586 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because configured rate mask excludes AP mandatory rate.\n",
5587 network->ssid_len, network->ssid,
5588 network->bssid);
5589 return 0;
5590 }
5591
5592 if (rates.num_rates == 0) {
5593 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of no compatible rates.\n",
5594 network->ssid_len, network->ssid,
5595 network->bssid);
5596 return 0;
5597 }
5598
5599
5600
5601
5602
5603
5604 ipw_copy_rates(&match->rates, &rates);
5605 match->network = network;
5606 IPW_DEBUG_MERGE("Network '%*pE (%pM)' is a viable match.\n",
5607 network->ssid_len, network->ssid, network->bssid);
5608
5609 return 1;
5610 }
5611
5612 static void ipw_merge_adhoc_network(struct work_struct *work)
5613 {
5614 struct ipw_priv *priv =
5615 container_of(work, struct ipw_priv, merge_networks);
5616 struct libipw_network *network = NULL;
5617 struct ipw_network_match match = {
5618 .network = priv->assoc_network
5619 };
5620
5621 if ((priv->status & STATUS_ASSOCIATED) &&
5622 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5623
5624
5625 unsigned long flags;
5626
5627 spin_lock_irqsave(&priv->ieee->lock, flags);
5628 list_for_each_entry(network, &priv->ieee->network_list, list) {
5629 if (network != priv->assoc_network)
5630 ipw_find_adhoc_network(priv, &match, network,
5631 1);
5632 }
5633 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5634
5635 if (match.network == priv->assoc_network) {
5636 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5637 "merge to.\n");
5638 return;
5639 }
5640
5641 mutex_lock(&priv->mutex);
5642 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5643 IPW_DEBUG_MERGE("remove network %*pE\n",
5644 priv->essid_len, priv->essid);
5645 ipw_remove_current_network(priv);
5646 }
5647
5648 ipw_disassociate(priv);
5649 priv->assoc_network = match.network;
5650 mutex_unlock(&priv->mutex);
5651 return;
5652 }
5653 }
5654
5655 static int ipw_best_network(struct ipw_priv *priv,
5656 struct ipw_network_match *match,
5657 struct libipw_network *network, int roaming)
5658 {
5659 struct ipw_supported_rates rates;
5660
5661
5662
5663 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5664 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5665 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5666 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5667 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded due to capability mismatch.\n",
5668 network->ssid_len, network->ssid,
5669 network->bssid);
5670 return 0;
5671 }
5672
5673 if (unlikely(roaming)) {
5674
5675
5676 if ((network->ssid_len != match->network->ssid_len) ||
5677 memcmp(network->ssid, match->network->ssid,
5678 network->ssid_len)) {
5679 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of non-network ESSID.\n",
5680 network->ssid_len, network->ssid,
5681 network->bssid);
5682 return 0;
5683 }
5684 } else {
5685
5686
5687 if ((priv->config & CFG_STATIC_ESSID) &&
5688 ((network->ssid_len != priv->essid_len) ||
5689 memcmp(network->ssid, priv->essid,
5690 min(network->ssid_len, priv->essid_len)))) {
5691 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of ESSID mismatch: '%*pE'.\n",
5692 network->ssid_len, network->ssid,
5693 network->bssid, priv->essid_len,
5694 priv->essid);
5695 return 0;
5696 }
5697 }
5698
5699
5700
5701 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5702 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because '%*pE (%pM)' has a stronger signal.\n",
5703 network->ssid_len, network->ssid,
5704 network->bssid, match->network->ssid_len,
5705 match->network->ssid, match->network->bssid);
5706 return 0;
5707 }
5708
5709
5710
5711 if (network->last_associate &&
5712 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5713 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of storming (%ums since last assoc attempt).\n",
5714 network->ssid_len, network->ssid,
5715 network->bssid,
5716 jiffies_to_msecs(jiffies -
5717 network->last_associate));
5718 return 0;
5719 }
5720
5721
5722 if (priv->ieee->scan_age != 0 &&
5723 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5724 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of age: %ums.\n",
5725 network->ssid_len, network->ssid,
5726 network->bssid,
5727 jiffies_to_msecs(jiffies -
5728 network->last_scanned));
5729 return 0;
5730 }
5731
5732 if ((priv->config & CFG_STATIC_CHANNEL) &&
5733 (network->channel != priv->channel)) {
5734 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of channel mismatch: %d != %d.\n",
5735 network->ssid_len, network->ssid,
5736 network->bssid,
5737 network->channel, priv->channel);
5738 return 0;
5739 }
5740
5741
5742 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5743 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5744 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of privacy mismatch: %s != %s.\n",
5745 network->ssid_len, network->ssid,
5746 network->bssid,
5747 priv->capability & CAP_PRIVACY_ON ? "on" :
5748 "off",
5749 network->capability &
5750 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5751 return 0;
5752 }
5753
5754 if ((priv->config & CFG_STATIC_BSSID) &&
5755 !ether_addr_equal(network->bssid, priv->bssid)) {
5756 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of BSSID mismatch: %pM.\n",
5757 network->ssid_len, network->ssid,
5758 network->bssid, priv->bssid);
5759 return 0;
5760 }
5761
5762
5763 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5764 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of invalid frequency/mode combination.\n",
5765 network->ssid_len, network->ssid,
5766 network->bssid);
5767 return 0;
5768 }
5769
5770
5771 if (!libipw_is_valid_channel(priv->ieee, network->channel)) {
5772 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of invalid channel in current GEO\n",
5773 network->ssid_len, network->ssid,
5774 network->bssid);
5775 return 0;
5776 }
5777
5778
5779
5780 if (!ipw_compatible_rates(priv, network, &rates)) {
5781 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because configured rate mask excludes AP mandatory rate.\n",
5782 network->ssid_len, network->ssid,
5783 network->bssid);
5784 return 0;
5785 }
5786
5787 if (rates.num_rates == 0) {
5788 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of no compatible rates.\n",
5789 network->ssid_len, network->ssid,
5790 network->bssid);
5791 return 0;
5792 }
5793
5794
5795
5796
5797
5798
5799 ipw_copy_rates(&match->rates, &rates);
5800 match->network = network;
5801
5802 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' is a viable match.\n",
5803 network->ssid_len, network->ssid, network->bssid);
5804
5805 return 1;
5806 }
5807
5808 static void ipw_adhoc_create(struct ipw_priv *priv,
5809 struct libipw_network *network)
5810 {
5811 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
5812 int i;
5813
5814
5815
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
5827 case LIBIPW_52GHZ_BAND:
5828 network->mode = IEEE_A;
5829 i = libipw_channel_to_index(priv->ieee, priv->channel);
5830 BUG_ON(i == -1);
5831 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5832 IPW_WARNING("Overriding invalid channel\n");
5833 priv->channel = geo->a[0].channel;
5834 }
5835 break;
5836
5837 case LIBIPW_24GHZ_BAND:
5838 if (priv->ieee->mode & IEEE_G)
5839 network->mode = IEEE_G;
5840 else
5841 network->mode = IEEE_B;
5842 i = libipw_channel_to_index(priv->ieee, priv->channel);
5843 BUG_ON(i == -1);
5844 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5845 IPW_WARNING("Overriding invalid channel\n");
5846 priv->channel = geo->bg[0].channel;
5847 }
5848 break;
5849
5850 default:
5851 IPW_WARNING("Overriding invalid channel\n");
5852 if (priv->ieee->mode & IEEE_A) {
5853 network->mode = IEEE_A;
5854 priv->channel = geo->a[0].channel;
5855 } else if (priv->ieee->mode & IEEE_G) {
5856 network->mode = IEEE_G;
5857 priv->channel = geo->bg[0].channel;
5858 } else {
5859 network->mode = IEEE_B;
5860 priv->channel = geo->bg[0].channel;
5861 }
5862 break;
5863 }
5864
5865 network->channel = priv->channel;
5866 priv->config |= CFG_ADHOC_PERSIST;
5867 ipw_create_bssid(priv, network->bssid);
5868 network->ssid_len = priv->essid_len;
5869 memcpy(network->ssid, priv->essid, priv->essid_len);
5870 memset(&network->stats, 0, sizeof(network->stats));
5871 network->capability = WLAN_CAPABILITY_IBSS;
5872 if (!(priv->config & CFG_PREAMBLE_LONG))
5873 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5874 if (priv->capability & CAP_PRIVACY_ON)
5875 network->capability |= WLAN_CAPABILITY_PRIVACY;
5876 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5877 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5878 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5879 memcpy(network->rates_ex,
5880 &priv->rates.supported_rates[network->rates_len],
5881 network->rates_ex_len);
5882 network->last_scanned = 0;
5883 network->flags = 0;
5884 network->last_associate = 0;
5885 network->time_stamp[0] = 0;
5886 network->time_stamp[1] = 0;
5887 network->beacon_interval = 100;
5888 network->listen_interval = 10;
5889 network->atim_window = 0;
5890 network->wpa_ie_len = 0;
5891 network->rsn_ie_len = 0;
5892 }
5893
5894 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5895 {
5896 struct ipw_tgi_tx_key key;
5897
5898 if (!(priv->ieee->sec.flags & (1 << index)))
5899 return;
5900
5901 key.key_id = index;
5902 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5903 key.security_type = type;
5904 key.station_index = 0;
5905 key.flags = 0;
5906
5907 key.tx_counter[0] = cpu_to_le32(0);
5908 key.tx_counter[1] = cpu_to_le32(0);
5909
5910 ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
5911 }
5912
5913 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5914 {
5915 struct ipw_wep_key key;
5916 int i;
5917
5918 key.cmd_id = DINO_CMD_WEP_KEY;
5919 key.seq_num = 0;
5920
5921
5922
5923 for (i = 0; i < 4; i++) {
5924 key.key_index = i | type;
5925 if (!(priv->ieee->sec.flags & (1 << i))) {
5926 key.key_size = 0;
5927 continue;
5928 }
5929
5930 key.key_size = priv->ieee->sec.key_sizes[i];
5931 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
5932
5933 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
5934 }
5935 }
5936
5937 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5938 {
5939 if (priv->ieee->host_encrypt)
5940 return;
5941
5942 switch (level) {
5943 case SEC_LEVEL_3:
5944 priv->sys_config.disable_unicast_decryption = 0;
5945 priv->ieee->host_decrypt = 0;
5946 break;
5947 case SEC_LEVEL_2:
5948 priv->sys_config.disable_unicast_decryption = 1;
5949 priv->ieee->host_decrypt = 1;
5950 break;
5951 case SEC_LEVEL_1:
5952 priv->sys_config.disable_unicast_decryption = 0;
5953 priv->ieee->host_decrypt = 0;
5954 break;
5955 case SEC_LEVEL_0:
5956 priv->sys_config.disable_unicast_decryption = 1;
5957 break;
5958 default:
5959 break;
5960 }
5961 }
5962
5963 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5964 {
5965 if (priv->ieee->host_encrypt)
5966 return;
5967
5968 switch (level) {
5969 case SEC_LEVEL_3:
5970 priv->sys_config.disable_multicast_decryption = 0;
5971 break;
5972 case SEC_LEVEL_2:
5973 priv->sys_config.disable_multicast_decryption = 1;
5974 break;
5975 case SEC_LEVEL_1:
5976 priv->sys_config.disable_multicast_decryption = 0;
5977 break;
5978 case SEC_LEVEL_0:
5979 priv->sys_config.disable_multicast_decryption = 1;
5980 break;
5981 default:
5982 break;
5983 }
5984 }
5985
5986 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5987 {
5988 switch (priv->ieee->sec.level) {
5989 case SEC_LEVEL_3:
5990 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5991 ipw_send_tgi_tx_key(priv,
5992 DCT_FLAG_EXT_SECURITY_CCM,
5993 priv->ieee->sec.active_key);
5994
5995 if (!priv->ieee->host_mc_decrypt)
5996 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5997 break;
5998 case SEC_LEVEL_2:
5999 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
6000 ipw_send_tgi_tx_key(priv,
6001 DCT_FLAG_EXT_SECURITY_TKIP,
6002 priv->ieee->sec.active_key);
6003 break;
6004 case SEC_LEVEL_1:
6005 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
6006 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
6007 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
6008 break;
6009 case SEC_LEVEL_0:
6010 default:
6011 break;
6012 }
6013 }
6014
6015 static void ipw_adhoc_check(void *data)
6016 {
6017 struct ipw_priv *priv = data;
6018
6019 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
6020 !(priv->config & CFG_ADHOC_PERSIST)) {
6021 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
6022 IPW_DL_STATE | IPW_DL_ASSOC,
6023 "Missed beacon: %d - disassociate\n",
6024 priv->missed_adhoc_beacons);
6025 ipw_remove_current_network(priv);
6026 ipw_disassociate(priv);
6027 return;
6028 }
6029
6030 schedule_delayed_work(&priv->adhoc_check,
6031 le16_to_cpu(priv->assoc_request.beacon_interval));
6032 }
6033
6034 static void ipw_bg_adhoc_check(struct work_struct *work)
6035 {
6036 struct ipw_priv *priv =
6037 container_of(work, struct ipw_priv, adhoc_check.work);
6038 mutex_lock(&priv->mutex);
6039 ipw_adhoc_check(priv);
6040 mutex_unlock(&priv->mutex);
6041 }
6042
6043 static void ipw_debug_config(struct ipw_priv *priv)
6044 {
6045 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
6046 "[CFG 0x%08X]\n", priv->config);
6047 if (priv->config & CFG_STATIC_CHANNEL)
6048 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
6049 else
6050 IPW_DEBUG_INFO("Channel unlocked.\n");
6051 if (priv->config & CFG_STATIC_ESSID)
6052 IPW_DEBUG_INFO("ESSID locked to '%*pE'\n",
6053 priv->essid_len, priv->essid);
6054 else
6055 IPW_DEBUG_INFO("ESSID unlocked.\n");
6056 if (priv->config & CFG_STATIC_BSSID)
6057 IPW_DEBUG_INFO("BSSID locked to %pM\n", priv->bssid);
6058 else
6059 IPW_DEBUG_INFO("BSSID unlocked.\n");
6060 if (priv->capability & CAP_PRIVACY_ON)
6061 IPW_DEBUG_INFO("PRIVACY on\n");
6062 else
6063 IPW_DEBUG_INFO("PRIVACY off\n");
6064 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
6065 }
6066
6067 static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
6068 {
6069
6070 struct ipw_fixed_rate fr;
6071 u32 reg;
6072 u16 mask = 0;
6073 u16 new_tx_rates = priv->rates_mask;
6074
6075
6076
6077
6078 switch (priv->ieee->freq_band) {
6079 case LIBIPW_52GHZ_BAND:
6080
6081 if (priv->rates_mask & ~LIBIPW_OFDM_RATES_MASK) {
6082
6083 IPW_DEBUG_WX
6084 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6085 new_tx_rates = 0;
6086 break;
6087 }
6088
6089 new_tx_rates >>= LIBIPW_OFDM_SHIFT_MASK_A;
6090 break;
6091
6092 default:
6093
6094 if (mode == IEEE_B) {
6095 if (new_tx_rates & ~LIBIPW_CCK_RATES_MASK) {
6096
6097 IPW_DEBUG_WX
6098 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6099 new_tx_rates = 0;
6100 }
6101 break;
6102 }
6103
6104
6105 if (new_tx_rates & ~(LIBIPW_CCK_RATES_MASK |
6106 LIBIPW_OFDM_RATES_MASK)) {
6107
6108 IPW_DEBUG_WX
6109 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6110 new_tx_rates = 0;
6111 break;
6112 }
6113
6114 if (LIBIPW_OFDM_RATE_6MB_MASK & new_tx_rates) {
6115 mask |= (LIBIPW_OFDM_RATE_6MB_MASK >> 1);
6116 new_tx_rates &= ~LIBIPW_OFDM_RATE_6MB_MASK;
6117 }
6118
6119 if (LIBIPW_OFDM_RATE_9MB_MASK & new_tx_rates) {
6120 mask |= (LIBIPW_OFDM_RATE_9MB_MASK >> 1);
6121 new_tx_rates &= ~LIBIPW_OFDM_RATE_9MB_MASK;
6122 }
6123
6124 if (LIBIPW_OFDM_RATE_12MB_MASK & new_tx_rates) {
6125 mask |= (LIBIPW_OFDM_RATE_12MB_MASK >> 1);
6126 new_tx_rates &= ~LIBIPW_OFDM_RATE_12MB_MASK;
6127 }
6128
6129 new_tx_rates |= mask;
6130 break;
6131 }
6132
6133 fr.tx_rates = cpu_to_le16(new_tx_rates);
6134
6135 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
6136 ipw_write_reg32(priv, reg, *(u32 *) & fr);
6137 }
6138
6139 static void ipw_abort_scan(struct ipw_priv *priv)
6140 {
6141 int err;
6142
6143 if (priv->status & STATUS_SCAN_ABORTING) {
6144 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
6145 return;
6146 }
6147 priv->status |= STATUS_SCAN_ABORTING;
6148
6149 err = ipw_send_scan_abort(priv);
6150 if (err)
6151 IPW_DEBUG_HC("Request to abort scan failed.\n");
6152 }
6153
6154 static void ipw_add_scan_channels(struct ipw_priv *priv,
6155 struct ipw_scan_request_ext *scan,
6156 int scan_type)
6157 {
6158 int channel_index = 0;
6159 const struct libipw_geo *geo;
6160 int i;
6161
6162 geo = libipw_get_geo(priv->ieee);
6163
6164 if (priv->ieee->freq_band & LIBIPW_52GHZ_BAND) {
6165 int start = channel_index;
6166 for (i = 0; i < geo->a_channels; i++) {
6167 if ((priv->status & STATUS_ASSOCIATED) &&
6168 geo->a[i].channel == priv->channel)
6169 continue;
6170 channel_index++;
6171 scan->channels_list[channel_index] = geo->a[i].channel;
6172 ipw_set_scan_type(scan, channel_index,
6173 geo->a[i].
6174 flags & LIBIPW_CH_PASSIVE_ONLY ?
6175 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
6176 scan_type);
6177 }
6178
6179 if (start != channel_index) {
6180 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
6181 (channel_index - start);
6182 channel_index++;
6183 }
6184 }
6185
6186 if (priv->ieee->freq_band & LIBIPW_24GHZ_BAND) {
6187 int start = channel_index;
6188 if (priv->config & CFG_SPEED_SCAN) {
6189 int index;
6190 u8 channels[LIBIPW_24GHZ_CHANNELS] = {
6191
6192 [0] = 0
6193 };
6194
6195 u8 channel;
6196 while (channel_index < IPW_SCAN_CHANNELS - 1) {
6197 channel =
6198 priv->speed_scan[priv->speed_scan_pos];
6199 if (channel == 0) {
6200 priv->speed_scan_pos = 0;
6201 channel = priv->speed_scan[0];
6202 }
6203 if ((priv->status & STATUS_ASSOCIATED) &&
6204 channel == priv->channel) {
6205 priv->speed_scan_pos++;
6206 continue;
6207 }
6208
6209
6210
6211
6212
6213
6214 if (channels[channel - 1] != 0)
6215 break;
6216
6217 channels[channel - 1] = 1;
6218 priv->speed_scan_pos++;
6219 channel_index++;
6220 scan->channels_list[channel_index] = channel;
6221 index =
6222 libipw_channel_to_index(priv->ieee, channel);
6223 ipw_set_scan_type(scan, channel_index,
6224 geo->bg[index].
6225 flags &
6226 LIBIPW_CH_PASSIVE_ONLY ?
6227 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6228 : scan_type);
6229 }
6230 } else {
6231 for (i = 0; i < geo->bg_channels; i++) {
6232 if ((priv->status & STATUS_ASSOCIATED) &&
6233 geo->bg[i].channel == priv->channel)
6234 continue;
6235 channel_index++;
6236 scan->channels_list[channel_index] =
6237 geo->bg[i].channel;
6238 ipw_set_scan_type(scan, channel_index,
6239 geo->bg[i].
6240 flags &
6241 LIBIPW_CH_PASSIVE_ONLY ?
6242 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6243 : scan_type);
6244 }
6245 }
6246
6247 if (start != channel_index) {
6248 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6249 (channel_index - start);
6250 }
6251 }
6252 }
6253
6254 static int ipw_passive_dwell_time(struct ipw_priv *priv)
6255 {
6256
6257
6258
6259
6260
6261 if (priv->status & STATUS_ASSOCIATED
6262 && priv->assoc_network->beacon_interval > 10)
6263 return priv->assoc_network->beacon_interval - 10;
6264 else
6265 return 120;
6266 }
6267
6268 static int ipw_request_scan_helper(struct ipw_priv *priv, int type, int direct)
6269 {
6270 struct ipw_scan_request_ext scan;
6271 int err = 0, scan_type;
6272
6273 if (!(priv->status & STATUS_INIT) ||
6274 (priv->status & STATUS_EXIT_PENDING))
6275 return 0;
6276
6277 mutex_lock(&priv->mutex);
6278
6279 if (direct && (priv->direct_scan_ssid_len == 0)) {
6280 IPW_DEBUG_HC("Direct scan requested but no SSID to scan for\n");
6281 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6282 goto done;
6283 }
6284
6285 if (priv->status & STATUS_SCANNING) {
6286 IPW_DEBUG_HC("Concurrent scan requested. Queuing.\n");
6287 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6288 STATUS_SCAN_PENDING;
6289 goto done;
6290 }
6291
6292 if (!(priv->status & STATUS_SCAN_FORCED) &&
6293 priv->status & STATUS_SCAN_ABORTING) {
6294 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6295 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6296 STATUS_SCAN_PENDING;
6297 goto done;
6298 }
6299
6300 if (priv->status & STATUS_RF_KILL_MASK) {
6301 IPW_DEBUG_HC("Queuing scan due to RF Kill activation\n");
6302 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6303 STATUS_SCAN_PENDING;
6304 goto done;
6305 }
6306
6307 memset(&scan, 0, sizeof(scan));
6308 scan.full_scan_index = cpu_to_le32(libipw_get_scans(priv->ieee));
6309
6310 if (type == IW_SCAN_TYPE_PASSIVE) {
6311 IPW_DEBUG_WX("use passive scanning\n");
6312 scan_type = IPW_SCAN_PASSIVE_FULL_DWELL_SCAN;
6313 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6314 cpu_to_le16(ipw_passive_dwell_time(priv));
6315 ipw_add_scan_channels(priv, &scan, scan_type);
6316 goto send_request;
6317 }
6318
6319
6320 if (priv->config & CFG_SPEED_SCAN)
6321 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6322 cpu_to_le16(30);
6323 else
6324 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6325 cpu_to_le16(20);
6326
6327 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6328 cpu_to_le16(20);
6329
6330 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6331 cpu_to_le16(ipw_passive_dwell_time(priv));
6332 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
6333
6334 #ifdef CONFIG_IPW2200_MONITOR
6335 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6336 u8 channel;
6337 u8 band = 0;
6338
6339 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
6340 case LIBIPW_52GHZ_BAND:
6341 band = (u8) (IPW_A_MODE << 6) | 1;
6342 channel = priv->channel;
6343 break;
6344
6345 case LIBIPW_24GHZ_BAND:
6346 band = (u8) (IPW_B_MODE << 6) | 1;
6347 channel = priv->channel;
6348 break;
6349
6350 default:
6351 band = (u8) (IPW_B_MODE << 6) | 1;
6352 channel = 9;
6353 break;
6354 }
6355
6356 scan.channels_list[0] = band;
6357 scan.channels_list[1] = channel;
6358 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6369 cpu_to_le16(2000);
6370 } else {
6371 #endif
6372
6373
6374
6375 if (direct) {
6376 err = ipw_send_ssid(priv, priv->direct_scan_ssid,
6377 priv->direct_scan_ssid_len);
6378 if (err) {
6379 IPW_DEBUG_HC("Attempt to send SSID command "
6380 "failed\n");
6381 goto done;
6382 }
6383
6384 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6385 } else if ((priv->status & STATUS_ROAMING)
6386 || (!(priv->status & STATUS_ASSOCIATED)
6387 && (priv->config & CFG_STATIC_ESSID)
6388 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6389 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6390 if (err) {
6391 IPW_DEBUG_HC("Attempt to send SSID command "
6392 "failed.\n");
6393 goto done;
6394 }
6395
6396 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6397 } else
6398 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6399
6400 ipw_add_scan_channels(priv, &scan, scan_type);
6401 #ifdef CONFIG_IPW2200_MONITOR
6402 }
6403 #endif
6404
6405 send_request:
6406 err = ipw_send_scan_request_ext(priv, &scan);
6407 if (err) {
6408 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6409 goto done;
6410 }
6411
6412 priv->status |= STATUS_SCANNING;
6413 if (direct) {
6414 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6415 priv->direct_scan_ssid_len = 0;
6416 } else
6417 priv->status &= ~STATUS_SCAN_PENDING;
6418
6419 schedule_delayed_work(&priv->scan_check, IPW_SCAN_CHECK_WATCHDOG);
6420 done:
6421 mutex_unlock(&priv->mutex);
6422 return err;
6423 }
6424
6425 static void ipw_request_passive_scan(struct work_struct *work)
6426 {
6427 struct ipw_priv *priv =
6428 container_of(work, struct ipw_priv, request_passive_scan.work);
6429 ipw_request_scan_helper(priv, IW_SCAN_TYPE_PASSIVE, 0);
6430 }
6431
6432 static void ipw_request_scan(struct work_struct *work)
6433 {
6434 struct ipw_priv *priv =
6435 container_of(work, struct ipw_priv, request_scan.work);
6436 ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 0);
6437 }
6438
6439 static void ipw_request_direct_scan(struct work_struct *work)
6440 {
6441 struct ipw_priv *priv =
6442 container_of(work, struct ipw_priv, request_direct_scan.work);
6443 ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 1);
6444 }
6445
6446 static void ipw_bg_abort_scan(struct work_struct *work)
6447 {
6448 struct ipw_priv *priv =
6449 container_of(work, struct ipw_priv, abort_scan);
6450 mutex_lock(&priv->mutex);
6451 ipw_abort_scan(priv);
6452 mutex_unlock(&priv->mutex);
6453 }
6454
6455 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6456 {
6457
6458
6459 priv->ieee->wpa_enabled = value;
6460 return 0;
6461 }
6462
6463 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6464 {
6465 struct libipw_device *ieee = priv->ieee;
6466 struct libipw_security sec = {
6467 .flags = SEC_AUTH_MODE,
6468 };
6469 int ret = 0;
6470
6471 if (value & IW_AUTH_ALG_SHARED_KEY) {
6472 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6473 ieee->open_wep = 0;
6474 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6475 sec.auth_mode = WLAN_AUTH_OPEN;
6476 ieee->open_wep = 1;
6477 } else if (value & IW_AUTH_ALG_LEAP) {
6478 sec.auth_mode = WLAN_AUTH_LEAP;
6479 ieee->open_wep = 1;
6480 } else
6481 return -EINVAL;
6482
6483 if (ieee->set_security)
6484 ieee->set_security(ieee->dev, &sec);
6485 else
6486 ret = -EOPNOTSUPP;
6487
6488 return ret;
6489 }
6490
6491 static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6492 int wpa_ie_len)
6493 {
6494
6495 ipw_wpa_enable(priv, 1);
6496 }
6497
6498 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6499 char *capabilities, int length)
6500 {
6501 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6502
6503 return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
6504 capabilities);
6505 }
6506
6507
6508
6509
6510
6511
6512 static int ipw_wx_set_genie(struct net_device *dev,
6513 struct iw_request_info *info,
6514 union iwreq_data *wrqu, char *extra)
6515 {
6516 struct ipw_priv *priv = libipw_priv(dev);
6517 struct libipw_device *ieee = priv->ieee;
6518 u8 *buf;
6519 int err = 0;
6520
6521 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6522 (wrqu->data.length && extra == NULL))
6523 return -EINVAL;
6524
6525 if (wrqu->data.length) {
6526 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
6527 if (buf == NULL) {
6528 err = -ENOMEM;
6529 goto out;
6530 }
6531
6532 kfree(ieee->wpa_ie);
6533 ieee->wpa_ie = buf;
6534 ieee->wpa_ie_len = wrqu->data.length;
6535 } else {
6536 kfree(ieee->wpa_ie);
6537 ieee->wpa_ie = NULL;
6538 ieee->wpa_ie_len = 0;
6539 }
6540
6541 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6542 out:
6543 return err;
6544 }
6545
6546
6547 static int ipw_wx_get_genie(struct net_device *dev,
6548 struct iw_request_info *info,
6549 union iwreq_data *wrqu, char *extra)
6550 {
6551 struct ipw_priv *priv = libipw_priv(dev);
6552 struct libipw_device *ieee = priv->ieee;
6553 int err = 0;
6554
6555 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6556 wrqu->data.length = 0;
6557 goto out;
6558 }
6559
6560 if (wrqu->data.length < ieee->wpa_ie_len) {
6561 err = -E2BIG;
6562 goto out;
6563 }
6564
6565 wrqu->data.length = ieee->wpa_ie_len;
6566 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6567
6568 out:
6569 return err;
6570 }
6571
6572 static int wext_cipher2level(int cipher)
6573 {
6574 switch (cipher) {
6575 case IW_AUTH_CIPHER_NONE:
6576 return SEC_LEVEL_0;
6577 case IW_AUTH_CIPHER_WEP40:
6578 case IW_AUTH_CIPHER_WEP104:
6579 return SEC_LEVEL_1;
6580 case IW_AUTH_CIPHER_TKIP:
6581 return SEC_LEVEL_2;
6582 case IW_AUTH_CIPHER_CCMP:
6583 return SEC_LEVEL_3;
6584 default:
6585 return -1;
6586 }
6587 }
6588
6589
6590 static int ipw_wx_set_auth(struct net_device *dev,
6591 struct iw_request_info *info,
6592 union iwreq_data *wrqu, char *extra)
6593 {
6594 struct ipw_priv *priv = libipw_priv(dev);
6595 struct libipw_device *ieee = priv->ieee;
6596 struct iw_param *param = &wrqu->param;
6597 struct lib80211_crypt_data *crypt;
6598 unsigned long flags;
6599 int ret = 0;
6600
6601 switch (param->flags & IW_AUTH_INDEX) {
6602 case IW_AUTH_WPA_VERSION:
6603 break;
6604 case IW_AUTH_CIPHER_PAIRWISE:
6605 ipw_set_hw_decrypt_unicast(priv,
6606 wext_cipher2level(param->value));
6607 break;
6608 case IW_AUTH_CIPHER_GROUP:
6609 ipw_set_hw_decrypt_multicast(priv,
6610 wext_cipher2level(param->value));
6611 break;
6612 case IW_AUTH_KEY_MGMT:
6613
6614
6615
6616 break;
6617
6618 case IW_AUTH_TKIP_COUNTERMEASURES:
6619 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6620 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6621 break;
6622
6623 flags = crypt->ops->get_flags(crypt->priv);
6624
6625 if (param->value)
6626 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6627 else
6628 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6629
6630 crypt->ops->set_flags(flags, crypt->priv);
6631
6632 break;
6633
6634 case IW_AUTH_DROP_UNENCRYPTED:{
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644
6645
6646 struct libipw_security sec = {
6647 .flags = SEC_ENABLED,
6648 .enabled = param->value,
6649 };
6650 priv->ieee->drop_unencrypted = param->value;
6651
6652
6653
6654 if (!param->value) {
6655 sec.flags |= SEC_LEVEL;
6656 sec.level = SEC_LEVEL_0;
6657 } else {
6658 sec.flags |= SEC_LEVEL;
6659 sec.level = SEC_LEVEL_1;
6660 }
6661 if (priv->ieee->set_security)
6662 priv->ieee->set_security(priv->ieee->dev, &sec);
6663 break;
6664 }
6665
6666 case IW_AUTH_80211_AUTH_ALG:
6667 ret = ipw_wpa_set_auth_algs(priv, param->value);
6668 break;
6669
6670 case IW_AUTH_WPA_ENABLED:
6671 ret = ipw_wpa_enable(priv, param->value);
6672 ipw_disassociate(priv);
6673 break;
6674
6675 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6676 ieee->ieee802_1x = param->value;
6677 break;
6678
6679 case IW_AUTH_PRIVACY_INVOKED:
6680 ieee->privacy_invoked = param->value;
6681 break;
6682
6683 default:
6684 return -EOPNOTSUPP;
6685 }
6686 return ret;
6687 }
6688
6689
6690 static int ipw_wx_get_auth(struct net_device *dev,
6691 struct iw_request_info *info,
6692 union iwreq_data *wrqu, char *extra)
6693 {
6694 struct ipw_priv *priv = libipw_priv(dev);
6695 struct libipw_device *ieee = priv->ieee;
6696 struct lib80211_crypt_data *crypt;
6697 struct iw_param *param = &wrqu->param;
6698
6699 switch (param->flags & IW_AUTH_INDEX) {
6700 case IW_AUTH_WPA_VERSION:
6701 case IW_AUTH_CIPHER_PAIRWISE:
6702 case IW_AUTH_CIPHER_GROUP:
6703 case IW_AUTH_KEY_MGMT:
6704
6705
6706
6707 return -EOPNOTSUPP;
6708
6709 case IW_AUTH_TKIP_COUNTERMEASURES:
6710 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6711 if (!crypt || !crypt->ops->get_flags)
6712 break;
6713
6714 param->value = (crypt->ops->get_flags(crypt->priv) &
6715 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6716
6717 break;
6718
6719 case IW_AUTH_DROP_UNENCRYPTED:
6720 param->value = ieee->drop_unencrypted;
6721 break;
6722
6723 case IW_AUTH_80211_AUTH_ALG:
6724 param->value = ieee->sec.auth_mode;
6725 break;
6726
6727 case IW_AUTH_WPA_ENABLED:
6728 param->value = ieee->wpa_enabled;
6729 break;
6730
6731 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6732 param->value = ieee->ieee802_1x;
6733 break;
6734
6735 case IW_AUTH_ROAMING_CONTROL:
6736 case IW_AUTH_PRIVACY_INVOKED:
6737 param->value = ieee->privacy_invoked;
6738 break;
6739
6740 default:
6741 return -EOPNOTSUPP;
6742 }
6743 return 0;
6744 }
6745
6746
6747 static int ipw_wx_set_encodeext(struct net_device *dev,
6748 struct iw_request_info *info,
6749 union iwreq_data *wrqu, char *extra)
6750 {
6751 struct ipw_priv *priv = libipw_priv(dev);
6752 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6753
6754 if (hwcrypto) {
6755 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6756
6757
6758 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6759 priv->ieee->host_mc_decrypt = 1;
6760 else {
6761 priv->ieee->host_encrypt = 0;
6762 priv->ieee->host_encrypt_msdu = 1;
6763 priv->ieee->host_decrypt = 1;
6764 }
6765 } else {
6766 priv->ieee->host_encrypt = 0;
6767 priv->ieee->host_encrypt_msdu = 0;
6768 priv->ieee->host_decrypt = 0;
6769 priv->ieee->host_mc_decrypt = 0;
6770 }
6771 }
6772
6773 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6774 }
6775
6776
6777 static int ipw_wx_get_encodeext(struct net_device *dev,
6778 struct iw_request_info *info,
6779 union iwreq_data *wrqu, char *extra)
6780 {
6781 struct ipw_priv *priv = libipw_priv(dev);
6782 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6783 }
6784
6785
6786 static int ipw_wx_set_mlme(struct net_device *dev,
6787 struct iw_request_info *info,
6788 union iwreq_data *wrqu, char *extra)
6789 {
6790 struct ipw_priv *priv = libipw_priv(dev);
6791 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6792 __le16 reason;
6793
6794 reason = cpu_to_le16(mlme->reason_code);
6795
6796 switch (mlme->cmd) {
6797 case IW_MLME_DEAUTH:
6798
6799 break;
6800
6801 case IW_MLME_DISASSOC:
6802 ipw_disassociate(priv);
6803 break;
6804
6805 default:
6806 return -EOPNOTSUPP;
6807 }
6808 return 0;
6809 }
6810
6811 #ifdef CONFIG_IPW2200_QOS
6812
6813
6814
6815
6816
6817
6818 static u8 ipw_qos_current_mode(struct ipw_priv * priv)
6819 {
6820 u8 mode = 0;
6821
6822 if (priv->status & STATUS_ASSOCIATED) {
6823 unsigned long flags;
6824
6825 spin_lock_irqsave(&priv->ieee->lock, flags);
6826 mode = priv->assoc_network->mode;
6827 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6828 } else {
6829 mode = priv->ieee->mode;
6830 }
6831 IPW_DEBUG_QOS("QoS network/card mode %d\n", mode);
6832 return mode;
6833 }
6834
6835
6836
6837
6838 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6839 int active_network,
6840 struct libipw_network *network)
6841 {
6842 u32 size = sizeof(struct libipw_qos_parameters);
6843
6844 if (network->capability & WLAN_CAPABILITY_IBSS)
6845 network->qos_data.active = network->qos_data.supported;
6846
6847 if (network->flags & NETWORK_HAS_QOS_MASK) {
6848 if (active_network &&
6849 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6850 network->qos_data.active = network->qos_data.supported;
6851
6852 if ((network->qos_data.active == 1) && (active_network == 1) &&
6853 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6854 (network->qos_data.old_param_count !=
6855 network->qos_data.param_count)) {
6856 network->qos_data.old_param_count =
6857 network->qos_data.param_count;
6858 schedule_work(&priv->qos_activate);
6859 IPW_DEBUG_QOS("QoS parameters change call "
6860 "qos_activate\n");
6861 }
6862 } else {
6863 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6864 memcpy(&network->qos_data.parameters,
6865 &def_parameters_CCK, size);
6866 else
6867 memcpy(&network->qos_data.parameters,
6868 &def_parameters_OFDM, size);
6869
6870 if ((network->qos_data.active == 1) && (active_network == 1)) {
6871 IPW_DEBUG_QOS("QoS was disabled call qos_activate\n");
6872 schedule_work(&priv->qos_activate);
6873 }
6874
6875 network->qos_data.active = 0;
6876 network->qos_data.supported = 0;
6877 }
6878 if ((priv->status & STATUS_ASSOCIATED) &&
6879 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6880 if (!ether_addr_equal(network->bssid, priv->bssid))
6881 if (network->capability & WLAN_CAPABILITY_IBSS)
6882 if ((network->ssid_len ==
6883 priv->assoc_network->ssid_len) &&
6884 !memcmp(network->ssid,
6885 priv->assoc_network->ssid,
6886 network->ssid_len)) {
6887 schedule_work(&priv->merge_networks);
6888 }
6889 }
6890
6891 return 0;
6892 }
6893
6894
6895
6896
6897
6898 static int ipw_qos_activate(struct ipw_priv *priv,
6899 struct libipw_qos_data *qos_network_data)
6900 {
6901 int err;
6902 struct libipw_qos_parameters qos_parameters[QOS_QOS_SETS];
6903 struct libipw_qos_parameters *active_one = NULL;
6904 u32 size = sizeof(struct libipw_qos_parameters);
6905 u32 burst_duration;
6906 int i;
6907 u8 type;
6908
6909 type = ipw_qos_current_mode(priv);
6910
6911 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6912 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6913 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6914 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6915
6916 if (qos_network_data == NULL) {
6917 if (type == IEEE_B) {
6918 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6919 active_one = &def_parameters_CCK;
6920 } else
6921 active_one = &def_parameters_OFDM;
6922
6923 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6924 burst_duration = ipw_qos_get_burst_duration(priv);
6925 for (i = 0; i < QOS_QUEUE_NUM; i++)
6926 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6927 cpu_to_le16(burst_duration);
6928 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6929 if (type == IEEE_B) {
6930 IPW_DEBUG_QOS("QoS activate IBSS network mode %d\n",
6931 type);
6932 if (priv->qos_data.qos_enable == 0)
6933 active_one = &def_parameters_CCK;
6934 else
6935 active_one = priv->qos_data.def_qos_parm_CCK;
6936 } else {
6937 if (priv->qos_data.qos_enable == 0)
6938 active_one = &def_parameters_OFDM;
6939 else
6940 active_one = priv->qos_data.def_qos_parm_OFDM;
6941 }
6942 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6943 } else {
6944 unsigned long flags;
6945 int active;
6946
6947 spin_lock_irqsave(&priv->ieee->lock, flags);
6948 active_one = &(qos_network_data->parameters);
6949 qos_network_data->old_param_count =
6950 qos_network_data->param_count;
6951 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6952 active = qos_network_data->supported;
6953 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6954
6955 if (active == 0) {
6956 burst_duration = ipw_qos_get_burst_duration(priv);
6957 for (i = 0; i < QOS_QUEUE_NUM; i++)
6958 qos_parameters[QOS_PARAM_SET_ACTIVE].
6959 tx_op_limit[i] = cpu_to_le16(burst_duration);
6960 }
6961 }
6962
6963 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6964 err = ipw_send_qos_params_command(priv, &qos_parameters[0]);
6965 if (err)
6966 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6967
6968 return err;
6969 }
6970
6971
6972
6973
6974 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6975 {
6976 int ret = 0;
6977 struct libipw_qos_information_element qos_info;
6978
6979 if (priv == NULL)
6980 return -1;
6981
6982 qos_info.elementID = QOS_ELEMENT_ID;
6983 qos_info.length = sizeof(struct libipw_qos_information_element) - 2;
6984
6985 qos_info.version = QOS_VERSION_1;
6986 qos_info.ac_info = 0;
6987
6988 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6989 qos_info.qui_type = QOS_OUI_TYPE;
6990 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6991
6992 ret = ipw_send_qos_info_command(priv, &qos_info);
6993 if (ret != 0) {
6994 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6995 }
6996 return ret;
6997 }
6998
6999
7000
7001
7002 static int ipw_qos_association(struct ipw_priv *priv,
7003 struct libipw_network *network)
7004 {
7005 int err = 0;
7006 struct libipw_qos_data *qos_data = NULL;
7007 struct libipw_qos_data ibss_data = {
7008 .supported = 1,
7009 .active = 1,
7010 };
7011
7012 switch (priv->ieee->iw_mode) {
7013 case IW_MODE_ADHOC:
7014 BUG_ON(!(network->capability & WLAN_CAPABILITY_IBSS));
7015
7016 qos_data = &ibss_data;
7017 break;
7018
7019 case IW_MODE_INFRA:
7020 qos_data = &network->qos_data;
7021 break;
7022
7023 default:
7024 BUG();
7025 break;
7026 }
7027
7028 err = ipw_qos_activate(priv, qos_data);
7029 if (err) {
7030 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
7031 return err;
7032 }
7033
7034 if (priv->qos_data.qos_enable && qos_data->supported) {
7035 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
7036 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7037 return ipw_qos_set_info_element(priv);
7038 }
7039
7040 return 0;
7041 }
7042
7043
7044
7045
7046
7047
7048 static int ipw_qos_association_resp(struct ipw_priv *priv,
7049 struct libipw_network *network)
7050 {
7051 int ret = 0;
7052 unsigned long flags;
7053 u32 size = sizeof(struct libipw_qos_parameters);
7054 int set_qos_param = 0;
7055
7056 if ((priv == NULL) || (network == NULL) ||
7057 (priv->assoc_network == NULL))
7058 return ret;
7059
7060 if (!(priv->status & STATUS_ASSOCIATED))
7061 return ret;
7062
7063 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
7064 return ret;
7065
7066 spin_lock_irqsave(&priv->ieee->lock, flags);
7067 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
7068 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
7069 sizeof(struct libipw_qos_data));
7070 priv->assoc_network->qos_data.active = 1;
7071 if ((network->qos_data.old_param_count !=
7072 network->qos_data.param_count)) {
7073 set_qos_param = 1;
7074 network->qos_data.old_param_count =
7075 network->qos_data.param_count;
7076 }
7077
7078 } else {
7079 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7080 memcpy(&priv->assoc_network->qos_data.parameters,
7081 &def_parameters_CCK, size);
7082 else
7083 memcpy(&priv->assoc_network->qos_data.parameters,
7084 &def_parameters_OFDM, size);
7085 priv->assoc_network->qos_data.active = 0;
7086 priv->assoc_network->qos_data.supported = 0;
7087 set_qos_param = 1;
7088 }
7089
7090 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7091
7092 if (set_qos_param == 1)
7093 schedule_work(&priv->qos_activate);
7094
7095 return ret;
7096 }
7097
7098 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7099 {
7100 u32 ret = 0;
7101
7102 if (!priv)
7103 return 0;
7104
7105 if (!(priv->ieee->modulation & LIBIPW_OFDM_MODULATION))
7106 ret = priv->qos_data.burst_duration_CCK;
7107 else
7108 ret = priv->qos_data.burst_duration_OFDM;
7109
7110 return ret;
7111 }
7112
7113
7114
7115
7116 static void ipw_qos_init(struct ipw_priv *priv, int enable,
7117 int burst_enable, u32 burst_duration_CCK,
7118 u32 burst_duration_OFDM)
7119 {
7120 priv->qos_data.qos_enable = enable;
7121
7122 if (priv->qos_data.qos_enable) {
7123 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7124 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7125 IPW_DEBUG_QOS("QoS is enabled\n");
7126 } else {
7127 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7128 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7129 IPW_DEBUG_QOS("QoS is not enabled\n");
7130 }
7131
7132 priv->qos_data.burst_enable = burst_enable;
7133
7134 if (burst_enable) {
7135 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7136 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7137 } else {
7138 priv->qos_data.burst_duration_CCK = 0;
7139 priv->qos_data.burst_duration_OFDM = 0;
7140 }
7141 }
7142
7143
7144
7145
7146 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7147 {
7148 if (priority > 7 || !priv->qos_data.qos_enable)
7149 priority = 0;
7150
7151 return from_priority_to_tx_queue[priority] - 1;
7152 }
7153
7154 static int ipw_is_qos_active(struct net_device *dev,
7155 struct sk_buff *skb)
7156 {
7157 struct ipw_priv *priv = libipw_priv(dev);
7158 struct libipw_qos_data *qos_data = NULL;
7159 int active, supported;
7160 u8 *daddr = skb->data + ETH_ALEN;
7161 int unicast = !is_multicast_ether_addr(daddr);
7162
7163 if (!(priv->status & STATUS_ASSOCIATED))
7164 return 0;
7165
7166 qos_data = &priv->assoc_network->qos_data;
7167
7168 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7169 if (unicast == 0)
7170 qos_data->active = 0;
7171 else
7172 qos_data->active = qos_data->supported;
7173 }
7174 active = qos_data->active;
7175 supported = qos_data->supported;
7176 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
7177 "unicast %d\n",
7178 priv->qos_data.qos_enable, active, supported, unicast);
7179 if (active && priv->qos_data.qos_enable)
7180 return 1;
7181
7182 return 0;
7183
7184 }
7185
7186
7187
7188 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7189 u16 priority,
7190 struct tfd_data *tfd)
7191 {
7192 int tx_queue_id = 0;
7193
7194
7195 tx_queue_id = from_priority_to_tx_queue[priority] - 1;
7196 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7197
7198 if (priv->qos_data.qos_no_ack_mask & (1UL << tx_queue_id)) {
7199 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
7200 tfd->tfd.tfd_26.mchdr.qos_ctrl |= cpu_to_le16(CTRL_QOS_NO_ACK);
7201 }
7202 return 0;
7203 }
7204
7205
7206
7207
7208 static void ipw_bg_qos_activate(struct work_struct *work)
7209 {
7210 struct ipw_priv *priv =
7211 container_of(work, struct ipw_priv, qos_activate);
7212
7213 mutex_lock(&priv->mutex);
7214
7215 if (priv->status & STATUS_ASSOCIATED)
7216 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7217
7218 mutex_unlock(&priv->mutex);
7219 }
7220
7221 static int ipw_handle_probe_response(struct net_device *dev,
7222 struct libipw_probe_response *resp,
7223 struct libipw_network *network)
7224 {
7225 struct ipw_priv *priv = libipw_priv(dev);
7226 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7227 (network == priv->assoc_network));
7228
7229 ipw_qos_handle_probe_response(priv, active_network, network);
7230
7231 return 0;
7232 }
7233
7234 static int ipw_handle_beacon(struct net_device *dev,
7235 struct libipw_beacon *resp,
7236 struct libipw_network *network)
7237 {
7238 struct ipw_priv *priv = libipw_priv(dev);
7239 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7240 (network == priv->assoc_network));
7241
7242 ipw_qos_handle_probe_response(priv, active_network, network);
7243
7244 return 0;
7245 }
7246
7247 static int ipw_handle_assoc_response(struct net_device *dev,
7248 struct libipw_assoc_response *resp,
7249 struct libipw_network *network)
7250 {
7251 struct ipw_priv *priv = libipw_priv(dev);
7252 ipw_qos_association_resp(priv, network);
7253 return 0;
7254 }
7255
7256 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
7257 *qos_param)
7258 {
7259 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7260 sizeof(*qos_param) * 3, qos_param);
7261 }
7262
7263 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
7264 *qos_param)
7265 {
7266 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7267 qos_param);
7268 }
7269
7270 #endif
7271
7272 static int ipw_associate_network(struct ipw_priv *priv,
7273 struct libipw_network *network,
7274 struct ipw_supported_rates *rates, int roaming)
7275 {
7276 int err;
7277
7278 if (priv->config & CFG_FIXED_RATE)
7279 ipw_set_fixed_rate(priv, network->mode);
7280
7281 if (!(priv->config & CFG_STATIC_ESSID)) {
7282 priv->essid_len = min(network->ssid_len,
7283 (u8) IW_ESSID_MAX_SIZE);
7284 memcpy(priv->essid, network->ssid, priv->essid_len);
7285 }
7286
7287 network->last_associate = jiffies;
7288
7289 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7290 priv->assoc_request.channel = network->channel;
7291 priv->assoc_request.auth_key = 0;
7292
7293 if ((priv->capability & CAP_PRIVACY_ON) &&
7294 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7295 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7296 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7297
7298 if (priv->ieee->sec.level == SEC_LEVEL_1)
7299 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7300
7301 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7302 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7303 priv->assoc_request.auth_type = AUTH_LEAP;
7304 else
7305 priv->assoc_request.auth_type = AUTH_OPEN;
7306
7307 if (priv->ieee->wpa_ie_len) {
7308 priv->assoc_request.policy_support = cpu_to_le16(0x02);
7309 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7310 priv->ieee->wpa_ie_len);
7311 }
7312
7313
7314
7315
7316
7317
7318 if (network->mode & priv->ieee->mode & IEEE_A)
7319 priv->assoc_request.ieee_mode = IPW_A_MODE;
7320 else if (network->mode & priv->ieee->mode & IEEE_G)
7321 priv->assoc_request.ieee_mode = IPW_G_MODE;
7322 else if (network->mode & priv->ieee->mode & IEEE_B)
7323 priv->assoc_request.ieee_mode = IPW_B_MODE;
7324
7325 priv->assoc_request.capability = cpu_to_le16(network->capability);
7326 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7327 && !(priv->config & CFG_PREAMBLE_LONG)) {
7328 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7329 } else {
7330 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7331
7332
7333 priv->assoc_request.capability &=
7334 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
7335 }
7336
7337
7338 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7339 priv->assoc_request.capability &=
7340 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME);
7341
7342 IPW_DEBUG_ASSOC("%ssociation attempt: '%*pE', channel %d, 802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7343 roaming ? "Rea" : "A",
7344 priv->essid_len, priv->essid,
7345 network->channel,
7346 ipw_modes[priv->assoc_request.ieee_mode],
7347 rates->num_rates,
7348 (priv->assoc_request.preamble_length ==
7349 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7350 network->capability &
7351 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7352 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7353 priv->capability & CAP_PRIVACY_ON ?
7354 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7355 "(open)") : "",
7356 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7357 priv->capability & CAP_PRIVACY_ON ?
7358 '1' + priv->ieee->sec.active_key : '.',
7359 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7360
7361 priv->assoc_request.beacon_interval = cpu_to_le16(network->beacon_interval);
7362 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7363 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7364 priv->assoc_request.assoc_type = HC_IBSS_START;
7365 priv->assoc_request.assoc_tsf_msw = 0;
7366 priv->assoc_request.assoc_tsf_lsw = 0;
7367 } else {
7368 if (unlikely(roaming))
7369 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7370 else
7371 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7372 priv->assoc_request.assoc_tsf_msw = cpu_to_le32(network->time_stamp[1]);
7373 priv->assoc_request.assoc_tsf_lsw = cpu_to_le32(network->time_stamp[0]);
7374 }
7375
7376 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7377
7378 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7379 eth_broadcast_addr(priv->assoc_request.dest);
7380 priv->assoc_request.atim_window = cpu_to_le16(network->atim_window);
7381 } else {
7382 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7383 priv->assoc_request.atim_window = 0;
7384 }
7385
7386 priv->assoc_request.listen_interval = cpu_to_le16(network->listen_interval);
7387
7388 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7389 if (err) {
7390 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7391 return err;
7392 }
7393
7394 rates->ieee_mode = priv->assoc_request.ieee_mode;
7395 rates->purpose = IPW_RATE_CONNECT;
7396 ipw_send_supported_rates(priv, rates);
7397
7398 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7399 priv->sys_config.dot11g_auto_detection = 1;
7400 else
7401 priv->sys_config.dot11g_auto_detection = 0;
7402
7403 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7404 priv->sys_config.answer_broadcast_ssid_probe = 1;
7405 else
7406 priv->sys_config.answer_broadcast_ssid_probe = 0;
7407
7408 err = ipw_send_system_config(priv);
7409 if (err) {
7410 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7411 return err;
7412 }
7413
7414 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7415 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7416 if (err) {
7417 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7418 return err;
7419 }
7420
7421
7422
7423
7424
7425
7426 priv->channel = network->channel;
7427 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7428 priv->status |= STATUS_ASSOCIATING;
7429 priv->status &= ~STATUS_SECURITY_UPDATED;
7430
7431 priv->assoc_network = network;
7432
7433 #ifdef CONFIG_IPW2200_QOS
7434 ipw_qos_association(priv, network);
7435 #endif
7436
7437 err = ipw_send_associate(priv, &priv->assoc_request);
7438 if (err) {
7439 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7440 return err;
7441 }
7442
7443 IPW_DEBUG(IPW_DL_STATE, "associating: '%*pE' %pM\n",
7444 priv->essid_len, priv->essid, priv->bssid);
7445
7446 return 0;
7447 }
7448
7449 static void ipw_roam(void *data)
7450 {
7451 struct ipw_priv *priv = data;
7452 struct libipw_network *network = NULL;
7453 struct ipw_network_match match = {
7454 .network = priv->assoc_network
7455 };
7456
7457
7458
7459
7460
7461
7462
7463
7464
7465
7466
7467
7468
7469
7470
7471
7472
7473
7474
7475
7476
7477 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7478 return;
7479
7480 if (priv->status & STATUS_ASSOCIATED) {
7481
7482
7483 unsigned long flags;
7484 u8 rssi = priv->assoc_network->stats.rssi;
7485 priv->assoc_network->stats.rssi = -128;
7486 spin_lock_irqsave(&priv->ieee->lock, flags);
7487 list_for_each_entry(network, &priv->ieee->network_list, list) {
7488 if (network != priv->assoc_network)
7489 ipw_best_network(priv, &match, network, 1);
7490 }
7491 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7492 priv->assoc_network->stats.rssi = rssi;
7493
7494 if (match.network == priv->assoc_network) {
7495 IPW_DEBUG_ASSOC("No better APs in this network to "
7496 "roam to.\n");
7497 priv->status &= ~STATUS_ROAMING;
7498 ipw_debug_config(priv);
7499 return;
7500 }
7501
7502 ipw_send_disassociate(priv, 1);
7503 priv->assoc_network = match.network;
7504
7505 return;
7506 }
7507
7508
7509 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7510 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7511 priv->status &= ~STATUS_ROAMING;
7512 }
7513
7514 static void ipw_bg_roam(struct work_struct *work)
7515 {
7516 struct ipw_priv *priv =
7517 container_of(work, struct ipw_priv, roam);
7518 mutex_lock(&priv->mutex);
7519 ipw_roam(priv);
7520 mutex_unlock(&priv->mutex);
7521 }
7522
7523 static int ipw_associate(void *data)
7524 {
7525 struct ipw_priv *priv = data;
7526
7527 struct libipw_network *network = NULL;
7528 struct ipw_network_match match = {
7529 .network = NULL
7530 };
7531 struct ipw_supported_rates *rates;
7532 struct list_head *element;
7533 unsigned long flags;
7534
7535 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7536 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7537 return 0;
7538 }
7539
7540 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7541 IPW_DEBUG_ASSOC("Not attempting association (already in "
7542 "progress)\n");
7543 return 0;
7544 }
7545
7546 if (priv->status & STATUS_DISASSOCIATING) {
7547 IPW_DEBUG_ASSOC("Not attempting association (in disassociating)\n");
7548 schedule_work(&priv->associate);
7549 return 0;
7550 }
7551
7552 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7553 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7554 "initialized)\n");
7555 return 0;
7556 }
7557
7558 if (!(priv->config & CFG_ASSOCIATE) &&
7559 !(priv->config & (CFG_STATIC_ESSID | CFG_STATIC_BSSID))) {
7560 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7561 return 0;
7562 }
7563
7564
7565 spin_lock_irqsave(&priv->ieee->lock, flags);
7566 list_for_each_entry(network, &priv->ieee->network_list, list)
7567 ipw_best_network(priv, &match, network, 0);
7568
7569 network = match.network;
7570 rates = &match.rates;
7571
7572 if (network == NULL &&
7573 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7574 priv->config & CFG_ADHOC_CREATE &&
7575 priv->config & CFG_STATIC_ESSID &&
7576 priv->config & CFG_STATIC_CHANNEL) {
7577
7578 if (list_empty(&priv->ieee->network_free_list)) {
7579 struct libipw_network *oldest = NULL;
7580 struct libipw_network *target;
7581
7582 list_for_each_entry(target, &priv->ieee->network_list, list) {
7583 if ((oldest == NULL) ||
7584 (target->last_scanned < oldest->last_scanned))
7585 oldest = target;
7586 }
7587
7588
7589 list_del(&oldest->list);
7590 target = oldest;
7591 IPW_DEBUG_ASSOC("Expired '%*pE' (%pM) from network list.\n",
7592 target->ssid_len, target->ssid,
7593 target->bssid);
7594 list_add_tail(&target->list,
7595 &priv->ieee->network_free_list);
7596 }
7597
7598 element = priv->ieee->network_free_list.next;
7599 network = list_entry(element, struct libipw_network, list);
7600 ipw_adhoc_create(priv, network);
7601 rates = &priv->rates;
7602 list_del(element);
7603 list_add_tail(&network->list, &priv->ieee->network_list);
7604 }
7605 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7606
7607
7608
7609 if (!network) {
7610 ipw_debug_config(priv);
7611
7612 if (!(priv->status & STATUS_SCANNING)) {
7613 if (!(priv->config & CFG_SPEED_SCAN))
7614 schedule_delayed_work(&priv->request_scan,
7615 SCAN_INTERVAL);
7616 else
7617 schedule_delayed_work(&priv->request_scan, 0);
7618 }
7619
7620 return 0;
7621 }
7622
7623 ipw_associate_network(priv, network, rates, 0);
7624
7625 return 1;
7626 }
7627
7628 static void ipw_bg_associate(struct work_struct *work)
7629 {
7630 struct ipw_priv *priv =
7631 container_of(work, struct ipw_priv, associate);
7632 mutex_lock(&priv->mutex);
7633 ipw_associate(priv);
7634 mutex_unlock(&priv->mutex);
7635 }
7636
7637 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7638 struct sk_buff *skb)
7639 {
7640 struct ieee80211_hdr *hdr;
7641 u16 fc;
7642
7643 hdr = (struct ieee80211_hdr *)skb->data;
7644 fc = le16_to_cpu(hdr->frame_control);
7645 if (!(fc & IEEE80211_FCTL_PROTECTED))
7646 return;
7647
7648 fc &= ~IEEE80211_FCTL_PROTECTED;
7649 hdr->frame_control = cpu_to_le16(fc);
7650 switch (priv->ieee->sec.level) {
7651 case SEC_LEVEL_3:
7652
7653 memmove(skb->data + LIBIPW_3ADDR_LEN,
7654 skb->data + LIBIPW_3ADDR_LEN + 8,
7655 skb->len - LIBIPW_3ADDR_LEN - 8);
7656 skb_trim(skb, skb->len - 16);
7657 break;
7658 case SEC_LEVEL_2:
7659 break;
7660 case SEC_LEVEL_1:
7661
7662 memmove(skb->data + LIBIPW_3ADDR_LEN,
7663 skb->data + LIBIPW_3ADDR_LEN + 4,
7664 skb->len - LIBIPW_3ADDR_LEN - 4);
7665 skb_trim(skb, skb->len - 8);
7666 break;
7667 case SEC_LEVEL_0:
7668 break;
7669 default:
7670 printk(KERN_ERR "Unknown security level %d\n",
7671 priv->ieee->sec.level);
7672 break;
7673 }
7674 }
7675
7676 static void ipw_handle_data_packet(struct ipw_priv *priv,
7677 struct ipw_rx_mem_buffer *rxb,
7678 struct libipw_rx_stats *stats)
7679 {
7680 struct net_device *dev = priv->net_dev;
7681 struct libipw_hdr_4addr *hdr;
7682 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7683
7684
7685 netif_trans_update(dev);
7686
7687
7688
7689 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7690 skb_tailroom(rxb->skb))) {
7691 dev->stats.rx_errors++;
7692 priv->wstats.discard.misc++;
7693 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7694 return;
7695 } else if (unlikely(!netif_running(priv->net_dev))) {
7696 dev->stats.rx_dropped++;
7697 priv->wstats.discard.misc++;
7698 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7699 return;
7700 }
7701
7702
7703 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7704
7705
7706 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7707
7708 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7709
7710
7711 hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
7712 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7713 (is_multicast_ether_addr(hdr->addr1) ?
7714 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7715 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7716
7717 if (!libipw_rx(priv->ieee, rxb->skb, stats))
7718 dev->stats.rx_errors++;
7719 else {
7720 rxb->skb = NULL;
7721 __ipw_led_activity_on(priv);
7722 }
7723 }
7724
7725 #ifdef CONFIG_IPW2200_RADIOTAP
7726 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7727 struct ipw_rx_mem_buffer *rxb,
7728 struct libipw_rx_stats *stats)
7729 {
7730 struct net_device *dev = priv->net_dev;
7731 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7732 struct ipw_rx_frame *frame = &pkt->u.frame;
7733
7734
7735 u16 received_channel = frame->received_channel;
7736 u8 antennaAndPhy = frame->antennaAndPhy;
7737 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
7738 u16 pktrate = frame->rate;
7739
7740
7741
7742
7743 struct ipw_rt_hdr *ipw_rt;
7744
7745 unsigned short len = le16_to_cpu(pkt->u.frame.length);
7746
7747
7748 netif_trans_update(dev);
7749
7750
7751
7752 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7753 skb_tailroom(rxb->skb))) {
7754 dev->stats.rx_errors++;
7755 priv->wstats.discard.misc++;
7756 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7757 return;
7758 } else if (unlikely(!netif_running(priv->net_dev))) {
7759 dev->stats.rx_dropped++;
7760 priv->wstats.discard.misc++;
7761 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7762 return;
7763 }
7764
7765
7766
7767 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7768
7769 dev->stats.rx_dropped++;
7770 priv->wstats.discard.misc++;
7771 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7772 return;
7773 }
7774
7775
7776 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7777 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7778
7779 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7780
7781 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7782 ipw_rt->rt_hdr.it_pad = 0;
7783 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr));
7784
7785
7786 ipw_rt->rt_hdr.it_present = cpu_to_le32(
7787 (1 << IEEE80211_RADIOTAP_TSFT) |
7788 (1 << IEEE80211_RADIOTAP_FLAGS) |
7789 (1 << IEEE80211_RADIOTAP_RATE) |
7790 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7791 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7792 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
7793 (1 << IEEE80211_RADIOTAP_ANTENNA));
7794
7795
7796 ipw_rt->rt_flags = 0;
7797 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7798 frame->parent_tsf[2] << 16 |
7799 frame->parent_tsf[1] << 8 |
7800 frame->parent_tsf[0]);
7801
7802
7803 ipw_rt->rt_dbmsignal = antsignal;
7804 ipw_rt->rt_dbmnoise = (s8) le16_to_cpu(frame->noise);
7805
7806
7807 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7808 if (received_channel > 14) {
7809 ipw_rt->rt_chbitmask =
7810 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7811 } else if (antennaAndPhy & 32) {
7812 ipw_rt->rt_chbitmask =
7813 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7814 } else {
7815 ipw_rt->rt_chbitmask =
7816 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7817 }
7818
7819
7820 switch (pktrate) {
7821 case IPW_TX_RATE_1MB:
7822 ipw_rt->rt_rate = 2;
7823 break;
7824 case IPW_TX_RATE_2MB:
7825 ipw_rt->rt_rate = 4;
7826 break;
7827 case IPW_TX_RATE_5MB:
7828 ipw_rt->rt_rate = 10;
7829 break;
7830 case IPW_TX_RATE_6MB:
7831 ipw_rt->rt_rate = 12;
7832 break;
7833 case IPW_TX_RATE_9MB:
7834 ipw_rt->rt_rate = 18;
7835 break;
7836 case IPW_TX_RATE_11MB:
7837 ipw_rt->rt_rate = 22;
7838 break;
7839 case IPW_TX_RATE_12MB:
7840 ipw_rt->rt_rate = 24;
7841 break;
7842 case IPW_TX_RATE_18MB:
7843 ipw_rt->rt_rate = 36;
7844 break;
7845 case IPW_TX_RATE_24MB:
7846 ipw_rt->rt_rate = 48;
7847 break;
7848 case IPW_TX_RATE_36MB:
7849 ipw_rt->rt_rate = 72;
7850 break;
7851 case IPW_TX_RATE_48MB:
7852 ipw_rt->rt_rate = 96;
7853 break;
7854 case IPW_TX_RATE_54MB:
7855 ipw_rt->rt_rate = 108;
7856 break;
7857 default:
7858 ipw_rt->rt_rate = 0;
7859 break;
7860 }
7861
7862
7863 ipw_rt->rt_antenna = (antennaAndPhy & 3);
7864
7865
7866 if ((antennaAndPhy & 64))
7867 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7868
7869
7870 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7871
7872 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7873
7874 if (!libipw_rx(priv->ieee, rxb->skb, stats))
7875 dev->stats.rx_errors++;
7876 else {
7877 rxb->skb = NULL;
7878
7879 }
7880 }
7881 #endif
7882
7883 #ifdef CONFIG_IPW2200_PROMISCUOUS
7884 #define libipw_is_probe_response(fc) \
7885 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT && \
7886 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP )
7887
7888 #define libipw_is_management(fc) \
7889 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT)
7890
7891 #define libipw_is_control(fc) \
7892 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL)
7893
7894 #define libipw_is_data(fc) \
7895 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)
7896
7897 #define libipw_is_assoc_request(fc) \
7898 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_ASSOC_REQ)
7899
7900 #define libipw_is_reassoc_request(fc) \
7901 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_REASSOC_REQ)
7902
7903 static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
7904 struct ipw_rx_mem_buffer *rxb,
7905 struct libipw_rx_stats *stats)
7906 {
7907 struct net_device *dev = priv->prom_net_dev;
7908 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7909 struct ipw_rx_frame *frame = &pkt->u.frame;
7910 struct ipw_rt_hdr *ipw_rt;
7911
7912
7913
7914 struct ieee80211_hdr *hdr;
7915 u16 channel = frame->received_channel;
7916 u8 phy_flags = frame->antennaAndPhy;
7917 s8 signal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
7918 s8 noise = (s8) le16_to_cpu(frame->noise);
7919 u8 rate = frame->rate;
7920 unsigned short len = le16_to_cpu(pkt->u.frame.length);
7921 struct sk_buff *skb;
7922 int hdr_only = 0;
7923 u16 filter = priv->prom_priv->filter;
7924
7925
7926 if (filter & IPW_PROM_NO_RX)
7927 return;
7928
7929
7930 netif_trans_update(dev);
7931
7932 if (unlikely((len + IPW_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
7933 dev->stats.rx_errors++;
7934 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7935 return;
7936 }
7937
7938
7939 if (unlikely(!netif_running(dev))) {
7940 dev->stats.rx_dropped++;
7941 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7942 return;
7943 }
7944
7945
7946
7947 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7948
7949 dev->stats.rx_dropped++;
7950 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7951 return;
7952 }
7953
7954 hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
7955 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
7956 if (filter & IPW_PROM_NO_MGMT)
7957 return;
7958 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
7959 hdr_only = 1;
7960 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
7961 if (filter & IPW_PROM_NO_CTL)
7962 return;
7963 if (filter & IPW_PROM_CTL_HEADER_ONLY)
7964 hdr_only = 1;
7965 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
7966 if (filter & IPW_PROM_NO_DATA)
7967 return;
7968 if (filter & IPW_PROM_DATA_HEADER_ONLY)
7969 hdr_only = 1;
7970 }
7971
7972
7973 skb = skb_copy(rxb->skb, GFP_ATOMIC);
7974 if (skb == NULL) {
7975 IPW_ERROR("skb_clone failed for promiscuous copy.\n");
7976 return;
7977 }
7978
7979
7980 ipw_rt = (void *)skb->data;
7981
7982 if (hdr_only)
7983 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
7984
7985 memcpy(ipw_rt->payload, hdr, len);
7986
7987 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7988 ipw_rt->rt_hdr.it_pad = 0;
7989 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt));
7990
7991
7992 skb_put(skb, sizeof(*ipw_rt) + len);
7993
7994
7995 ipw_rt->rt_hdr.it_present = cpu_to_le32(
7996 (1 << IEEE80211_RADIOTAP_TSFT) |
7997 (1 << IEEE80211_RADIOTAP_FLAGS) |
7998 (1 << IEEE80211_RADIOTAP_RATE) |
7999 (1 << IEEE80211_RADIOTAP_CHANNEL) |
8000 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
8001 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
8002 (1 << IEEE80211_RADIOTAP_ANTENNA));
8003
8004
8005 ipw_rt->rt_flags = 0;
8006 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
8007 frame->parent_tsf[2] << 16 |
8008 frame->parent_tsf[1] << 8 |
8009 frame->parent_tsf[0]);
8010
8011
8012 ipw_rt->rt_dbmsignal = signal;
8013 ipw_rt->rt_dbmnoise = noise;
8014
8015
8016 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(channel));
8017 if (channel > 14) {
8018 ipw_rt->rt_chbitmask =
8019 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
8020 } else if (phy_flags & (1 << 5)) {
8021 ipw_rt->rt_chbitmask =
8022 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
8023 } else {
8024 ipw_rt->rt_chbitmask =
8025 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
8026 }
8027
8028
8029 switch (rate) {
8030 case IPW_TX_RATE_1MB:
8031 ipw_rt->rt_rate = 2;
8032 break;
8033 case IPW_TX_RATE_2MB:
8034 ipw_rt->rt_rate = 4;
8035 break;
8036 case IPW_TX_RATE_5MB:
8037 ipw_rt->rt_rate = 10;
8038 break;
8039 case IPW_TX_RATE_6MB:
8040 ipw_rt->rt_rate = 12;
8041 break;
8042 case IPW_TX_RATE_9MB:
8043 ipw_rt->rt_rate = 18;
8044 break;
8045 case IPW_TX_RATE_11MB:
8046 ipw_rt->rt_rate = 22;
8047 break;
8048 case IPW_TX_RATE_12MB:
8049 ipw_rt->rt_rate = 24;
8050 break;
8051 case IPW_TX_RATE_18MB:
8052 ipw_rt->rt_rate = 36;
8053 break;
8054 case IPW_TX_RATE_24MB:
8055 ipw_rt->rt_rate = 48;
8056 break;
8057 case IPW_TX_RATE_36MB:
8058 ipw_rt->rt_rate = 72;
8059 break;
8060 case IPW_TX_RATE_48MB:
8061 ipw_rt->rt_rate = 96;
8062 break;
8063 case IPW_TX_RATE_54MB:
8064 ipw_rt->rt_rate = 108;
8065 break;
8066 default:
8067 ipw_rt->rt_rate = 0;
8068 break;
8069 }
8070
8071
8072 ipw_rt->rt_antenna = (phy_flags & 3);
8073
8074
8075 if (phy_flags & (1 << 6))
8076 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8077
8078 IPW_DEBUG_RX("Rx packet of %d bytes.\n", skb->len);
8079
8080 if (!libipw_rx(priv->prom_priv->ieee, skb, stats)) {
8081 dev->stats.rx_errors++;
8082 dev_kfree_skb_any(skb);
8083 }
8084 }
8085 #endif
8086
8087 static int is_network_packet(struct ipw_priv *priv,
8088 struct libipw_hdr_4addr *header)
8089 {
8090
8091
8092 switch (priv->ieee->iw_mode) {
8093 case IW_MODE_ADHOC:
8094
8095 if (ether_addr_equal(header->addr2, priv->net_dev->dev_addr))
8096 return 0;
8097
8098
8099 if (is_multicast_ether_addr(header->addr1))
8100 return ether_addr_equal(header->addr3, priv->bssid);
8101
8102
8103 return ether_addr_equal(header->addr1,
8104 priv->net_dev->dev_addr);
8105
8106 case IW_MODE_INFRA:
8107
8108 if (ether_addr_equal(header->addr3, priv->net_dev->dev_addr))
8109 return 0;
8110
8111
8112 if (is_multicast_ether_addr(header->addr1))
8113 return ether_addr_equal(header->addr2, priv->bssid);
8114
8115
8116 return ether_addr_equal(header->addr1,
8117 priv->net_dev->dev_addr);
8118 }
8119
8120 return 1;
8121 }
8122
8123 #define IPW_PACKET_RETRY_TIME HZ
8124
8125 static int is_duplicate_packet(struct ipw_priv *priv,
8126 struct libipw_hdr_4addr *header)
8127 {
8128 u16 sc = le16_to_cpu(header->seq_ctl);
8129 u16 seq = WLAN_GET_SEQ_SEQ(sc);
8130 u16 frag = WLAN_GET_SEQ_FRAG(sc);
8131 u16 *last_seq, *last_frag;
8132 unsigned long *last_time;
8133
8134 switch (priv->ieee->iw_mode) {
8135 case IW_MODE_ADHOC:
8136 {
8137 struct list_head *p;
8138 struct ipw_ibss_seq *entry = NULL;
8139 u8 *mac = header->addr2;
8140 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8141
8142 list_for_each(p, &priv->ibss_mac_hash[index]) {
8143 entry =
8144 list_entry(p, struct ipw_ibss_seq, list);
8145 if (ether_addr_equal(entry->mac, mac))
8146 break;
8147 }
8148 if (p == &priv->ibss_mac_hash[index]) {
8149 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8150 if (!entry) {
8151 IPW_ERROR
8152 ("Cannot malloc new mac entry\n");
8153 return 0;
8154 }
8155 memcpy(entry->mac, mac, ETH_ALEN);
8156 entry->seq_num = seq;
8157 entry->frag_num = frag;
8158 entry->packet_time = jiffies;
8159 list_add(&entry->list,
8160 &priv->ibss_mac_hash[index]);
8161 return 0;
8162 }
8163 last_seq = &entry->seq_num;
8164 last_frag = &entry->frag_num;
8165 last_time = &entry->packet_time;
8166 break;
8167 }
8168 case IW_MODE_INFRA:
8169 last_seq = &priv->last_seq_num;
8170 last_frag = &priv->last_frag_num;
8171 last_time = &priv->last_packet_time;
8172 break;
8173 default:
8174 return 0;
8175 }
8176 if ((*last_seq == seq) &&
8177 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8178 if (*last_frag == frag)
8179 goto drop;
8180 if (*last_frag + 1 != frag)
8181
8182 goto drop;
8183 } else
8184 *last_seq = seq;
8185
8186 *last_frag = frag;
8187 *last_time = jiffies;
8188 return 0;
8189
8190 drop:
8191
8192
8193
8194
8195 return 1;
8196 }
8197
8198 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8199 struct ipw_rx_mem_buffer *rxb,
8200 struct libipw_rx_stats *stats)
8201 {
8202 struct sk_buff *skb = rxb->skb;
8203 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8204 struct libipw_hdr_4addr *header = (struct libipw_hdr_4addr *)
8205 (skb->data + IPW_RX_FRAME_SIZE);
8206
8207 libipw_rx_mgt(priv->ieee, header, stats);
8208
8209 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8210 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8211 IEEE80211_STYPE_PROBE_RESP) ||
8212 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8213 IEEE80211_STYPE_BEACON))) {
8214 if (ether_addr_equal(header->addr3, priv->bssid))
8215 ipw_add_station(priv, header->addr2);
8216 }
8217
8218 if (priv->config & CFG_NET_STATS) {
8219 IPW_DEBUG_HC("sending stat packet\n");
8220
8221
8222
8223 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8224 IPW_RX_FRAME_SIZE);
8225
8226
8227 skb_pull(skb, IPW_RX_FRAME_SIZE);
8228
8229
8230 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8231
8232 skb->dev = priv->ieee->dev;
8233
8234
8235 skb_reset_mac_header(skb);
8236
8237 skb->pkt_type = PACKET_OTHERHOST;
8238 skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
8239 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8240 netif_rx(skb);
8241 rxb->skb = NULL;
8242 }
8243 }
8244
8245
8246
8247
8248
8249
8250 static void ipw_rx(struct ipw_priv *priv)
8251 {
8252 struct ipw_rx_mem_buffer *rxb;
8253 struct ipw_rx_packet *pkt;
8254 struct libipw_hdr_4addr *header;
8255 u32 r, w, i;
8256 u8 network_packet;
8257 u8 fill_rx = 0;
8258
8259 r = ipw_read32(priv, IPW_RX_READ_INDEX);
8260 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
8261 i = priv->rxq->read;
8262
8263 if (ipw_rx_queue_space (priv->rxq) > (RX_QUEUE_SIZE / 2))
8264 fill_rx = 1;
8265
8266 while (i != r) {
8267 rxb = priv->rxq->queue[i];
8268 if (unlikely(rxb == NULL)) {
8269 printk(KERN_CRIT "Queue not allocated!\n");
8270 break;
8271 }
8272 priv->rxq->queue[i] = NULL;
8273
8274 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
8275 IPW_RX_BUF_SIZE,
8276 PCI_DMA_FROMDEVICE);
8277
8278 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8279 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8280 pkt->header.message_type,
8281 pkt->header.rx_seq_num, pkt->header.control_bits);
8282
8283 switch (pkt->header.message_type) {
8284 case RX_FRAME_TYPE: {
8285 struct libipw_rx_stats stats = {
8286 .rssi = pkt->u.frame.rssi_dbm -
8287 IPW_RSSI_TO_DBM,
8288 .signal =
8289 pkt->u.frame.rssi_dbm -
8290 IPW_RSSI_TO_DBM + 0x100,
8291 .noise =
8292 le16_to_cpu(pkt->u.frame.noise),
8293 .rate = pkt->u.frame.rate,
8294 .mac_time = jiffies,
8295 .received_channel =
8296 pkt->u.frame.received_channel,
8297 .freq =
8298 (pkt->u.frame.
8299 control & (1 << 0)) ?
8300 LIBIPW_24GHZ_BAND :
8301 LIBIPW_52GHZ_BAND,
8302 .len = le16_to_cpu(pkt->u.frame.length),
8303 };
8304
8305 if (stats.rssi != 0)
8306 stats.mask |= LIBIPW_STATMASK_RSSI;
8307 if (stats.signal != 0)
8308 stats.mask |= LIBIPW_STATMASK_SIGNAL;
8309 if (stats.noise != 0)
8310 stats.mask |= LIBIPW_STATMASK_NOISE;
8311 if (stats.rate != 0)
8312 stats.mask |= LIBIPW_STATMASK_RATE;
8313
8314 priv->rx_packets++;
8315
8316 #ifdef CONFIG_IPW2200_PROMISCUOUS
8317 if (priv->prom_net_dev && netif_running(priv->prom_net_dev))
8318 ipw_handle_promiscuous_rx(priv, rxb, &stats);
8319 #endif
8320
8321 #ifdef CONFIG_IPW2200_MONITOR
8322 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8323 #ifdef CONFIG_IPW2200_RADIOTAP
8324
8325 ipw_handle_data_packet_monitor(priv,
8326 rxb,
8327 &stats);
8328 #else
8329 ipw_handle_data_packet(priv, rxb,
8330 &stats);
8331 #endif
8332 break;
8333 }
8334 #endif
8335
8336 header =
8337 (struct libipw_hdr_4addr *)(rxb->skb->
8338 data +
8339 IPW_RX_FRAME_SIZE);
8340
8341
8342
8343
8344
8345
8346 network_packet =
8347 is_network_packet(priv, header);
8348 if (network_packet && priv->assoc_network) {
8349 priv->assoc_network->stats.rssi =
8350 stats.rssi;
8351 priv->exp_avg_rssi =
8352 exponential_average(priv->exp_avg_rssi,
8353 stats.rssi, DEPTH_RSSI);
8354 }
8355
8356 IPW_DEBUG_RX("Frame: len=%u\n",
8357 le16_to_cpu(pkt->u.frame.length));
8358
8359 if (le16_to_cpu(pkt->u.frame.length) <
8360 libipw_get_hdrlen(le16_to_cpu(
8361 header->frame_ctl))) {
8362 IPW_DEBUG_DROP
8363 ("Received packet is too small. "
8364 "Dropping.\n");
8365 priv->net_dev->stats.rx_errors++;
8366 priv->wstats.discard.misc++;
8367 break;
8368 }
8369
8370 switch (WLAN_FC_GET_TYPE
8371 (le16_to_cpu(header->frame_ctl))) {
8372
8373 case IEEE80211_FTYPE_MGMT:
8374 ipw_handle_mgmt_packet(priv, rxb,
8375 &stats);
8376 break;
8377
8378 case IEEE80211_FTYPE_CTL:
8379 break;
8380
8381 case IEEE80211_FTYPE_DATA:
8382 if (unlikely(!network_packet ||
8383 is_duplicate_packet(priv,
8384 header)))
8385 {
8386 IPW_DEBUG_DROP("Dropping: "
8387 "%pM, "
8388 "%pM, "
8389 "%pM\n",
8390 header->addr1,
8391 header->addr2,
8392 header->addr3);
8393 break;
8394 }
8395
8396 ipw_handle_data_packet(priv, rxb,
8397 &stats);
8398
8399 break;
8400 }
8401 break;
8402 }
8403
8404 case RX_HOST_NOTIFICATION_TYPE:{
8405 IPW_DEBUG_RX
8406 ("Notification: subtype=%02X flags=%02X size=%d\n",
8407 pkt->u.notification.subtype,
8408 pkt->u.notification.flags,
8409 le16_to_cpu(pkt->u.notification.size));
8410 ipw_rx_notification(priv, &pkt->u.notification);
8411 break;
8412 }
8413
8414 default:
8415 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8416 pkt->header.message_type);
8417 break;
8418 }
8419
8420
8421
8422
8423 if (rxb->skb != NULL) {
8424 dev_kfree_skb_any(rxb->skb);
8425 rxb->skb = NULL;
8426 }
8427
8428 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
8429 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
8430 list_add_tail(&rxb->list, &priv->rxq->rx_used);
8431
8432 i = (i + 1) % RX_QUEUE_SIZE;
8433
8434
8435
8436 if (fill_rx) {
8437 priv->rxq->read = i;
8438 ipw_rx_queue_replenish(priv);
8439 }
8440 }
8441
8442
8443 priv->rxq->read = i;
8444 ipw_rx_queue_restock(priv);
8445 }
8446
8447 #define DEFAULT_RTS_THRESHOLD 2304U
8448 #define MIN_RTS_THRESHOLD 1U
8449 #define MAX_RTS_THRESHOLD 2304U
8450 #define DEFAULT_BEACON_INTERVAL 100U
8451 #define DEFAULT_SHORT_RETRY_LIMIT 7U
8452 #define DEFAULT_LONG_RETRY_LIMIT 4U
8453
8454
8455
8456
8457
8458
8459
8460
8461 static int ipw_sw_reset(struct ipw_priv *priv, int option)
8462 {
8463 int band, modulation;
8464 int old_mode = priv->ieee->iw_mode;
8465
8466
8467 priv->config = 0;
8468
8469
8470
8471 if (!led_support)
8472 priv->config |= CFG_NO_LED;
8473
8474 if (associate)
8475 priv->config |= CFG_ASSOCIATE;
8476 else
8477 IPW_DEBUG_INFO("Auto associate disabled.\n");
8478
8479 if (auto_create)
8480 priv->config |= CFG_ADHOC_CREATE;
8481 else
8482 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8483
8484 priv->config &= ~CFG_STATIC_ESSID;
8485 priv->essid_len = 0;
8486 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8487
8488 if (disable && option) {
8489 priv->status |= STATUS_RF_KILL_SW;
8490 IPW_DEBUG_INFO("Radio disabled.\n");
8491 }
8492
8493 if (default_channel != 0) {
8494 priv->config |= CFG_STATIC_CHANNEL;
8495 priv->channel = default_channel;
8496 IPW_DEBUG_INFO("Bind to static channel %d\n", default_channel);
8497
8498 }
8499 #ifdef CONFIG_IPW2200_QOS
8500 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8501 burst_duration_CCK, burst_duration_OFDM);
8502 #endif
8503
8504 switch (network_mode) {
8505 case 1:
8506 priv->ieee->iw_mode = IW_MODE_ADHOC;
8507 priv->net_dev->type = ARPHRD_ETHER;
8508
8509 break;
8510 #ifdef CONFIG_IPW2200_MONITOR
8511 case 2:
8512 priv->ieee->iw_mode = IW_MODE_MONITOR;
8513 #ifdef CONFIG_IPW2200_RADIOTAP
8514 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8515 #else
8516 priv->net_dev->type = ARPHRD_IEEE80211;
8517 #endif
8518 break;
8519 #endif
8520 default:
8521 case 0:
8522 priv->net_dev->type = ARPHRD_ETHER;
8523 priv->ieee->iw_mode = IW_MODE_INFRA;
8524 break;
8525 }
8526
8527 if (hwcrypto) {
8528 priv->ieee->host_encrypt = 0;
8529 priv->ieee->host_encrypt_msdu = 0;
8530 priv->ieee->host_decrypt = 0;
8531 priv->ieee->host_mc_decrypt = 0;
8532 }
8533 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8534
8535
8536 priv->ieee->host_open_frag = 0;
8537
8538 if ((priv->pci_dev->device == 0x4223) ||
8539 (priv->pci_dev->device == 0x4224)) {
8540 if (option == 1)
8541 printk(KERN_INFO DRV_NAME
8542 ": Detected Intel PRO/Wireless 2915ABG Network "
8543 "Connection\n");
8544 priv->ieee->abg_true = 1;
8545 band = LIBIPW_52GHZ_BAND | LIBIPW_24GHZ_BAND;
8546 modulation = LIBIPW_OFDM_MODULATION |
8547 LIBIPW_CCK_MODULATION;
8548 priv->adapter = IPW_2915ABG;
8549 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8550 } else {
8551 if (option == 1)
8552 printk(KERN_INFO DRV_NAME
8553 ": Detected Intel PRO/Wireless 2200BG Network "
8554 "Connection\n");
8555
8556 priv->ieee->abg_true = 0;
8557 band = LIBIPW_24GHZ_BAND;
8558 modulation = LIBIPW_OFDM_MODULATION |
8559 LIBIPW_CCK_MODULATION;
8560 priv->adapter = IPW_2200BG;
8561 priv->ieee->mode = IEEE_G | IEEE_B;
8562 }
8563
8564 priv->ieee->freq_band = band;
8565 priv->ieee->modulation = modulation;
8566
8567 priv->rates_mask = LIBIPW_DEFAULT_RATES_MASK;
8568
8569 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8570 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8571
8572 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8573 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8574 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8575
8576
8577 priv->power_mode = IPW_POWER_AC;
8578 priv->tx_power = IPW_TX_POWER_DEFAULT;
8579
8580 return old_mode == priv->ieee->iw_mode;
8581 }
8582
8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
8593 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8594 {
8595 if (channel == 0) {
8596 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8597 priv->config &= ~CFG_STATIC_CHANNEL;
8598 IPW_DEBUG_ASSOC("Attempting to associate with new "
8599 "parameters.\n");
8600 ipw_associate(priv);
8601 return 0;
8602 }
8603
8604 priv->config |= CFG_STATIC_CHANNEL;
8605
8606 if (priv->channel == channel) {
8607 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8608 channel);
8609 return 0;
8610 }
8611
8612 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8613 priv->channel = channel;
8614
8615 #ifdef CONFIG_IPW2200_MONITOR
8616 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8617 int i;
8618 if (priv->status & STATUS_SCANNING) {
8619 IPW_DEBUG_SCAN("Scan abort triggered due to "
8620 "channel change.\n");
8621 ipw_abort_scan(priv);
8622 }
8623
8624 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8625 udelay(10);
8626
8627 if (priv->status & STATUS_SCANNING)
8628 IPW_DEBUG_SCAN("Still scanning...\n");
8629 else
8630 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8631 1000 - i);
8632
8633 return 0;
8634 }
8635 #endif
8636
8637
8638 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8639 if (!ipw_disassociate(priv))
8640 ipw_associate(priv);
8641
8642 return 0;
8643 }
8644
8645 static int ipw_wx_set_freq(struct net_device *dev,
8646 struct iw_request_info *info,
8647 union iwreq_data *wrqu, char *extra)
8648 {
8649 struct ipw_priv *priv = libipw_priv(dev);
8650 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8651 struct iw_freq *fwrq = &wrqu->freq;
8652 int ret = 0, i;
8653 u8 channel, flags;
8654 int band;
8655
8656 if (fwrq->m == 0) {
8657 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8658 mutex_lock(&priv->mutex);
8659 ret = ipw_set_channel(priv, 0);
8660 mutex_unlock(&priv->mutex);
8661 return ret;
8662 }
8663
8664 if (fwrq->e == 1) {
8665 channel = libipw_freq_to_channel(priv->ieee, fwrq->m);
8666 if (channel == 0)
8667 return -EINVAL;
8668 } else
8669 channel = fwrq->m;
8670
8671 if (!(band = libipw_is_valid_channel(priv->ieee, channel)))
8672 return -EINVAL;
8673
8674 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8675 i = libipw_channel_to_index(priv->ieee, channel);
8676 if (i == -1)
8677 return -EINVAL;
8678
8679 flags = (band == LIBIPW_24GHZ_BAND) ?
8680 geo->bg[i].flags : geo->a[i].flags;
8681 if (flags & LIBIPW_CH_PASSIVE_ONLY) {
8682 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8683 return -EINVAL;
8684 }
8685 }
8686
8687 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
8688 mutex_lock(&priv->mutex);
8689 ret = ipw_set_channel(priv, channel);
8690 mutex_unlock(&priv->mutex);
8691 return ret;
8692 }
8693
8694 static int ipw_wx_get_freq(struct net_device *dev,
8695 struct iw_request_info *info,
8696 union iwreq_data *wrqu, char *extra)
8697 {
8698 struct ipw_priv *priv = libipw_priv(dev);
8699
8700 wrqu->freq.e = 0;
8701
8702
8703
8704 mutex_lock(&priv->mutex);
8705 if (priv->config & CFG_STATIC_CHANNEL ||
8706 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) {
8707 int i;
8708
8709 i = libipw_channel_to_index(priv->ieee, priv->channel);
8710 BUG_ON(i == -1);
8711 wrqu->freq.e = 1;
8712
8713 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
8714 case LIBIPW_52GHZ_BAND:
8715 wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000;
8716 break;
8717
8718 case LIBIPW_24GHZ_BAND:
8719 wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000;
8720 break;
8721
8722 default:
8723 BUG();
8724 }
8725 } else
8726 wrqu->freq.m = 0;
8727
8728 mutex_unlock(&priv->mutex);
8729 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
8730 return 0;
8731 }
8732
8733 static int ipw_wx_set_mode(struct net_device *dev,
8734 struct iw_request_info *info,
8735 union iwreq_data *wrqu, char *extra)
8736 {
8737 struct ipw_priv *priv = libipw_priv(dev);
8738 int err = 0;
8739
8740 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8741
8742 switch (wrqu->mode) {
8743 #ifdef CONFIG_IPW2200_MONITOR
8744 case IW_MODE_MONITOR:
8745 #endif
8746 case IW_MODE_ADHOC:
8747 case IW_MODE_INFRA:
8748 break;
8749 case IW_MODE_AUTO:
8750 wrqu->mode = IW_MODE_INFRA;
8751 break;
8752 default:
8753 return -EINVAL;
8754 }
8755 if (wrqu->mode == priv->ieee->iw_mode)
8756 return 0;
8757
8758 mutex_lock(&priv->mutex);
8759
8760 ipw_sw_reset(priv, 0);
8761
8762 #ifdef CONFIG_IPW2200_MONITOR
8763 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8764 priv->net_dev->type = ARPHRD_ETHER;
8765
8766 if (wrqu->mode == IW_MODE_MONITOR)
8767 #ifdef CONFIG_IPW2200_RADIOTAP
8768 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8769 #else
8770 priv->net_dev->type = ARPHRD_IEEE80211;
8771 #endif
8772 #endif
8773
8774
8775
8776 free_firmware();
8777
8778 priv->ieee->iw_mode = wrqu->mode;
8779
8780 schedule_work(&priv->adapter_restart);
8781 mutex_unlock(&priv->mutex);
8782 return err;
8783 }
8784
8785 static int ipw_wx_get_mode(struct net_device *dev,
8786 struct iw_request_info *info,
8787 union iwreq_data *wrqu, char *extra)
8788 {
8789 struct ipw_priv *priv = libipw_priv(dev);
8790 mutex_lock(&priv->mutex);
8791 wrqu->mode = priv->ieee->iw_mode;
8792 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8793 mutex_unlock(&priv->mutex);
8794 return 0;
8795 }
8796
8797
8798 static const s32 timeout_duration[] = {
8799 350000,
8800 250000,
8801 75000,
8802 37000,
8803 25000,
8804 };
8805
8806 static const s32 period_duration[] = {
8807 400000,
8808 700000,
8809 1000000,
8810 1000000,
8811 1000000
8812 };
8813
8814 static int ipw_wx_get_range(struct net_device *dev,
8815 struct iw_request_info *info,
8816 union iwreq_data *wrqu, char *extra)
8817 {
8818 struct ipw_priv *priv = libipw_priv(dev);
8819 struct iw_range *range = (struct iw_range *)extra;
8820 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8821 int i = 0, j;
8822
8823 wrqu->data.length = sizeof(*range);
8824 memset(range, 0, sizeof(*range));
8825
8826
8827 range->throughput = 27 * 1000 * 1000;
8828
8829 range->max_qual.qual = 100;
8830
8831 range->max_qual.level = 0;
8832 range->max_qual.noise = 0;
8833 range->max_qual.updated = 7;
8834
8835 range->avg_qual.qual = 70;
8836
8837 range->avg_qual.level = 0;
8838 range->avg_qual.noise = 0;
8839 range->avg_qual.updated = 7;
8840 mutex_lock(&priv->mutex);
8841 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8842
8843 for (i = 0; i < range->num_bitrates; i++)
8844 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8845 500000;
8846
8847 range->max_rts = DEFAULT_RTS_THRESHOLD;
8848 range->min_frag = MIN_FRAG_THRESHOLD;
8849 range->max_frag = MAX_FRAG_THRESHOLD;
8850
8851 range->encoding_size[0] = 5;
8852 range->encoding_size[1] = 13;
8853 range->num_encoding_sizes = 2;
8854 range->max_encoding_tokens = WEP_KEYS;
8855
8856
8857 range->we_version_compiled = WIRELESS_EXT;
8858 range->we_version_source = 18;
8859
8860 i = 0;
8861 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8862 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8863 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8864 (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8865 continue;
8866
8867 range->freq[i].i = geo->bg[j].channel;
8868 range->freq[i].m = geo->bg[j].freq * 100000;
8869 range->freq[i].e = 1;
8870 i++;
8871 }
8872 }
8873
8874 if (priv->ieee->mode & IEEE_A) {
8875 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8876 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8877 (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8878 continue;
8879
8880 range->freq[i].i = geo->a[j].channel;
8881 range->freq[i].m = geo->a[j].freq * 100000;
8882 range->freq[i].e = 1;
8883 i++;
8884 }
8885 }
8886
8887 range->num_channels = i;
8888 range->num_frequency = i;
8889
8890 mutex_unlock(&priv->mutex);
8891
8892
8893 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8894 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8895 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
8896 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
8897 range->event_capa[1] = IW_EVENT_CAPA_K_1;
8898
8899 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8900 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8901
8902 range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
8903
8904 IPW_DEBUG_WX("GET Range\n");
8905 return 0;
8906 }
8907
8908 static int ipw_wx_set_wap(struct net_device *dev,
8909 struct iw_request_info *info,
8910 union iwreq_data *wrqu, char *extra)
8911 {
8912 struct ipw_priv *priv = libipw_priv(dev);
8913
8914 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8915 return -EINVAL;
8916 mutex_lock(&priv->mutex);
8917 if (is_broadcast_ether_addr(wrqu->ap_addr.sa_data) ||
8918 is_zero_ether_addr(wrqu->ap_addr.sa_data)) {
8919
8920 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8921 priv->config &= ~CFG_STATIC_BSSID;
8922 IPW_DEBUG_ASSOC("Attempting to associate with new "
8923 "parameters.\n");
8924 ipw_associate(priv);
8925 mutex_unlock(&priv->mutex);
8926 return 0;
8927 }
8928
8929 priv->config |= CFG_STATIC_BSSID;
8930 if (ether_addr_equal(priv->bssid, wrqu->ap_addr.sa_data)) {
8931 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8932 mutex_unlock(&priv->mutex);
8933 return 0;
8934 }
8935
8936 IPW_DEBUG_WX("Setting mandatory BSSID to %pM\n",
8937 wrqu->ap_addr.sa_data);
8938
8939 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8940
8941
8942 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8943 if (!ipw_disassociate(priv))
8944 ipw_associate(priv);
8945
8946 mutex_unlock(&priv->mutex);
8947 return 0;
8948 }
8949
8950 static int ipw_wx_get_wap(struct net_device *dev,
8951 struct iw_request_info *info,
8952 union iwreq_data *wrqu, char *extra)
8953 {
8954 struct ipw_priv *priv = libipw_priv(dev);
8955
8956
8957
8958 mutex_lock(&priv->mutex);
8959 if (priv->config & CFG_STATIC_BSSID ||
8960 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8961 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8962 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8963 } else
8964 eth_zero_addr(wrqu->ap_addr.sa_data);
8965
8966 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n",
8967 wrqu->ap_addr.sa_data);
8968 mutex_unlock(&priv->mutex);
8969 return 0;
8970 }
8971
8972 static int ipw_wx_set_essid(struct net_device *dev,
8973 struct iw_request_info *info,
8974 union iwreq_data *wrqu, char *extra)
8975 {
8976 struct ipw_priv *priv = libipw_priv(dev);
8977 int length;
8978
8979 mutex_lock(&priv->mutex);
8980
8981 if (!wrqu->essid.flags)
8982 {
8983 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8984 ipw_disassociate(priv);
8985 priv->config &= ~CFG_STATIC_ESSID;
8986 ipw_associate(priv);
8987 mutex_unlock(&priv->mutex);
8988 return 0;
8989 }
8990
8991 length = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
8992
8993 priv->config |= CFG_STATIC_ESSID;
8994
8995 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)
8996 && (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
8997 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8998 mutex_unlock(&priv->mutex);
8999 return 0;
9000 }
9001
9002 IPW_DEBUG_WX("Setting ESSID: '%*pE' (%d)\n", length, extra, length);
9003
9004 priv->essid_len = length;
9005 memcpy(priv->essid, extra, priv->essid_len);
9006
9007
9008 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
9009 if (!ipw_disassociate(priv))
9010 ipw_associate(priv);
9011
9012 mutex_unlock(&priv->mutex);
9013 return 0;
9014 }
9015
9016 static int ipw_wx_get_essid(struct net_device *dev,
9017 struct iw_request_info *info,
9018 union iwreq_data *wrqu, char *extra)
9019 {
9020 struct ipw_priv *priv = libipw_priv(dev);
9021
9022
9023
9024 mutex_lock(&priv->mutex);
9025 if (priv->config & CFG_STATIC_ESSID ||
9026 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9027 IPW_DEBUG_WX("Getting essid: '%*pE'\n",
9028 priv->essid_len, priv->essid);
9029 memcpy(extra, priv->essid, priv->essid_len);
9030 wrqu->essid.length = priv->essid_len;
9031 wrqu->essid.flags = 1;
9032 } else {
9033 IPW_DEBUG_WX("Getting essid: ANY\n");
9034 wrqu->essid.length = 0;
9035 wrqu->essid.flags = 0;
9036 }
9037 mutex_unlock(&priv->mutex);
9038 return 0;
9039 }
9040
9041 static int ipw_wx_set_nick(struct net_device *dev,
9042 struct iw_request_info *info,
9043 union iwreq_data *wrqu, char *extra)
9044 {
9045 struct ipw_priv *priv = libipw_priv(dev);
9046
9047 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9048 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9049 return -E2BIG;
9050 mutex_lock(&priv->mutex);
9051 wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick));
9052 memset(priv->nick, 0, sizeof(priv->nick));
9053 memcpy(priv->nick, extra, wrqu->data.length);
9054 IPW_DEBUG_TRACE("<<\n");
9055 mutex_unlock(&priv->mutex);
9056 return 0;
9057
9058 }
9059
9060 static int ipw_wx_get_nick(struct net_device *dev,
9061 struct iw_request_info *info,
9062 union iwreq_data *wrqu, char *extra)
9063 {
9064 struct ipw_priv *priv = libipw_priv(dev);
9065 IPW_DEBUG_WX("Getting nick\n");
9066 mutex_lock(&priv->mutex);
9067 wrqu->data.length = strlen(priv->nick);
9068 memcpy(extra, priv->nick, wrqu->data.length);
9069 wrqu->data.flags = 1;
9070 mutex_unlock(&priv->mutex);
9071 return 0;
9072 }
9073
9074 static int ipw_wx_set_sens(struct net_device *dev,
9075 struct iw_request_info *info,
9076 union iwreq_data *wrqu, char *extra)
9077 {
9078 struct ipw_priv *priv = libipw_priv(dev);
9079 int err = 0;
9080
9081 IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
9082 IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
9083 mutex_lock(&priv->mutex);
9084
9085 if (wrqu->sens.fixed == 0)
9086 {
9087 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
9088 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
9089 goto out;
9090 }
9091 if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
9092 (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
9093 err = -EINVAL;
9094 goto out;
9095 }
9096
9097 priv->roaming_threshold = wrqu->sens.value;
9098 priv->disassociate_threshold = 3*wrqu->sens.value;
9099 out:
9100 mutex_unlock(&priv->mutex);
9101 return err;
9102 }
9103
9104 static int ipw_wx_get_sens(struct net_device *dev,
9105 struct iw_request_info *info,
9106 union iwreq_data *wrqu, char *extra)
9107 {
9108 struct ipw_priv *priv = libipw_priv(dev);
9109 mutex_lock(&priv->mutex);
9110 wrqu->sens.fixed = 1;
9111 wrqu->sens.value = priv->roaming_threshold;
9112 mutex_unlock(&priv->mutex);
9113
9114 IPW_DEBUG_WX("GET roaming threshold -> %s %d\n",
9115 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9116
9117 return 0;
9118 }
9119
9120 static int ipw_wx_set_rate(struct net_device *dev,
9121 struct iw_request_info *info,
9122 union iwreq_data *wrqu, char *extra)
9123 {
9124
9125 struct ipw_priv *priv = libipw_priv(dev);
9126 u32 target_rate = wrqu->bitrate.value;
9127 u32 fixed, mask;
9128
9129
9130
9131
9132
9133 if (target_rate == -1) {
9134 fixed = 0;
9135 mask = LIBIPW_DEFAULT_RATES_MASK;
9136
9137 goto apply;
9138 }
9139
9140 mask = 0;
9141 fixed = wrqu->bitrate.fixed;
9142
9143 if (target_rate == 1000000 || !fixed)
9144 mask |= LIBIPW_CCK_RATE_1MB_MASK;
9145 if (target_rate == 1000000)
9146 goto apply;
9147
9148 if (target_rate == 2000000 || !fixed)
9149 mask |= LIBIPW_CCK_RATE_2MB_MASK;
9150 if (target_rate == 2000000)
9151 goto apply;
9152
9153 if (target_rate == 5500000 || !fixed)
9154 mask |= LIBIPW_CCK_RATE_5MB_MASK;
9155 if (target_rate == 5500000)
9156 goto apply;
9157
9158 if (target_rate == 6000000 || !fixed)
9159 mask |= LIBIPW_OFDM_RATE_6MB_MASK;
9160 if (target_rate == 6000000)
9161 goto apply;
9162
9163 if (target_rate == 9000000 || !fixed)
9164 mask |= LIBIPW_OFDM_RATE_9MB_MASK;
9165 if (target_rate == 9000000)
9166 goto apply;
9167
9168 if (target_rate == 11000000 || !fixed)
9169 mask |= LIBIPW_CCK_RATE_11MB_MASK;
9170 if (target_rate == 11000000)
9171 goto apply;
9172
9173 if (target_rate == 12000000 || !fixed)
9174 mask |= LIBIPW_OFDM_RATE_12MB_MASK;
9175 if (target_rate == 12000000)
9176 goto apply;
9177
9178 if (target_rate == 18000000 || !fixed)
9179 mask |= LIBIPW_OFDM_RATE_18MB_MASK;
9180 if (target_rate == 18000000)
9181 goto apply;
9182
9183 if (target_rate == 24000000 || !fixed)
9184 mask |= LIBIPW_OFDM_RATE_24MB_MASK;
9185 if (target_rate == 24000000)
9186 goto apply;
9187
9188 if (target_rate == 36000000 || !fixed)
9189 mask |= LIBIPW_OFDM_RATE_36MB_MASK;
9190 if (target_rate == 36000000)
9191 goto apply;
9192
9193 if (target_rate == 48000000 || !fixed)
9194 mask |= LIBIPW_OFDM_RATE_48MB_MASK;
9195 if (target_rate == 48000000)
9196 goto apply;
9197
9198 if (target_rate == 54000000 || !fixed)
9199 mask |= LIBIPW_OFDM_RATE_54MB_MASK;
9200 if (target_rate == 54000000)
9201 goto apply;
9202
9203 IPW_DEBUG_WX("invalid rate specified, returning error\n");
9204 return -EINVAL;
9205
9206 apply:
9207 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9208 mask, fixed ? "fixed" : "sub-rates");
9209 mutex_lock(&priv->mutex);
9210 if (mask == LIBIPW_DEFAULT_RATES_MASK) {
9211 priv->config &= ~CFG_FIXED_RATE;
9212 ipw_set_fixed_rate(priv, priv->ieee->mode);
9213 } else
9214 priv->config |= CFG_FIXED_RATE;
9215
9216 if (priv->rates_mask == mask) {
9217 IPW_DEBUG_WX("Mask set to current mask.\n");
9218 mutex_unlock(&priv->mutex);
9219 return 0;
9220 }
9221
9222 priv->rates_mask = mask;
9223
9224
9225 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9226 if (!ipw_disassociate(priv))
9227 ipw_associate(priv);
9228
9229 mutex_unlock(&priv->mutex);
9230 return 0;
9231 }
9232
9233 static int ipw_wx_get_rate(struct net_device *dev,
9234 struct iw_request_info *info,
9235 union iwreq_data *wrqu, char *extra)
9236 {
9237 struct ipw_priv *priv = libipw_priv(dev);
9238 mutex_lock(&priv->mutex);
9239 wrqu->bitrate.value = priv->last_rate;
9240 wrqu->bitrate.fixed = (priv->config & CFG_FIXED_RATE) ? 1 : 0;
9241 mutex_unlock(&priv->mutex);
9242 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
9243 return 0;
9244 }
9245
9246 static int ipw_wx_set_rts(struct net_device *dev,
9247 struct iw_request_info *info,
9248 union iwreq_data *wrqu, char *extra)
9249 {
9250 struct ipw_priv *priv = libipw_priv(dev);
9251 mutex_lock(&priv->mutex);
9252 if (wrqu->rts.disabled || !wrqu->rts.fixed)
9253 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9254 else {
9255 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
9256 wrqu->rts.value > MAX_RTS_THRESHOLD) {
9257 mutex_unlock(&priv->mutex);
9258 return -EINVAL;
9259 }
9260 priv->rts_threshold = wrqu->rts.value;
9261 }
9262
9263 ipw_send_rts_threshold(priv, priv->rts_threshold);
9264 mutex_unlock(&priv->mutex);
9265 IPW_DEBUG_WX("SET RTS Threshold -> %d\n", priv->rts_threshold);
9266 return 0;
9267 }
9268
9269 static int ipw_wx_get_rts(struct net_device *dev,
9270 struct iw_request_info *info,
9271 union iwreq_data *wrqu, char *extra)
9272 {
9273 struct ipw_priv *priv = libipw_priv(dev);
9274 mutex_lock(&priv->mutex);
9275 wrqu->rts.value = priv->rts_threshold;
9276 wrqu->rts.fixed = 0;
9277 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
9278 mutex_unlock(&priv->mutex);
9279 IPW_DEBUG_WX("GET RTS Threshold -> %d\n", wrqu->rts.value);
9280 return 0;
9281 }
9282
9283 static int ipw_wx_set_txpow(struct net_device *dev,
9284 struct iw_request_info *info,
9285 union iwreq_data *wrqu, char *extra)
9286 {
9287 struct ipw_priv *priv = libipw_priv(dev);
9288 int err = 0;
9289
9290 mutex_lock(&priv->mutex);
9291 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
9292 err = -EINPROGRESS;
9293 goto out;
9294 }
9295
9296 if (!wrqu->power.fixed)
9297 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9298
9299 if (wrqu->power.flags != IW_TXPOW_DBM) {
9300 err = -EINVAL;
9301 goto out;
9302 }
9303
9304 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
9305 (wrqu->power.value < IPW_TX_POWER_MIN)) {
9306 err = -EINVAL;
9307 goto out;
9308 }
9309
9310 priv->tx_power = wrqu->power.value;
9311 err = ipw_set_tx_power(priv);
9312 out:
9313 mutex_unlock(&priv->mutex);
9314 return err;
9315 }
9316
9317 static int ipw_wx_get_txpow(struct net_device *dev,
9318 struct iw_request_info *info,
9319 union iwreq_data *wrqu, char *extra)
9320 {
9321 struct ipw_priv *priv = libipw_priv(dev);
9322 mutex_lock(&priv->mutex);
9323 wrqu->power.value = priv->tx_power;
9324 wrqu->power.fixed = 1;
9325 wrqu->power.flags = IW_TXPOW_DBM;
9326 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
9327 mutex_unlock(&priv->mutex);
9328
9329 IPW_DEBUG_WX("GET TX Power -> %s %d\n",
9330 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9331
9332 return 0;
9333 }
9334
9335 static int ipw_wx_set_frag(struct net_device *dev,
9336 struct iw_request_info *info,
9337 union iwreq_data *wrqu, char *extra)
9338 {
9339 struct ipw_priv *priv = libipw_priv(dev);
9340 mutex_lock(&priv->mutex);
9341 if (wrqu->frag.disabled || !wrqu->frag.fixed)
9342 priv->ieee->fts = DEFAULT_FTS;
9343 else {
9344 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
9345 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
9346 mutex_unlock(&priv->mutex);
9347 return -EINVAL;
9348 }
9349
9350 priv->ieee->fts = wrqu->frag.value & ~0x1;
9351 }
9352
9353 ipw_send_frag_threshold(priv, wrqu->frag.value);
9354 mutex_unlock(&priv->mutex);
9355 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", wrqu->frag.value);
9356 return 0;
9357 }
9358
9359 static int ipw_wx_get_frag(struct net_device *dev,
9360 struct iw_request_info *info,
9361 union iwreq_data *wrqu, char *extra)
9362 {
9363 struct ipw_priv *priv = libipw_priv(dev);
9364 mutex_lock(&priv->mutex);
9365 wrqu->frag.value = priv->ieee->fts;
9366 wrqu->frag.fixed = 0;
9367 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
9368 mutex_unlock(&priv->mutex);
9369 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
9370
9371 return 0;
9372 }
9373
9374 static int ipw_wx_set_retry(struct net_device *dev,
9375 struct iw_request_info *info,
9376 union iwreq_data *wrqu, char *extra)
9377 {
9378 struct ipw_priv *priv = libipw_priv(dev);
9379
9380 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9381 return -EINVAL;
9382
9383 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9384 return 0;
9385
9386 if (wrqu->retry.value < 0 || wrqu->retry.value >= 255)
9387 return -EINVAL;
9388
9389 mutex_lock(&priv->mutex);
9390 if (wrqu->retry.flags & IW_RETRY_SHORT)
9391 priv->short_retry_limit = (u8) wrqu->retry.value;
9392 else if (wrqu->retry.flags & IW_RETRY_LONG)
9393 priv->long_retry_limit = (u8) wrqu->retry.value;
9394 else {
9395 priv->short_retry_limit = (u8) wrqu->retry.value;
9396 priv->long_retry_limit = (u8) wrqu->retry.value;
9397 }
9398
9399 ipw_send_retry_limit(priv, priv->short_retry_limit,
9400 priv->long_retry_limit);
9401 mutex_unlock(&priv->mutex);
9402 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9403 priv->short_retry_limit, priv->long_retry_limit);
9404 return 0;
9405 }
9406
9407 static int ipw_wx_get_retry(struct net_device *dev,
9408 struct iw_request_info *info,
9409 union iwreq_data *wrqu, char *extra)
9410 {
9411 struct ipw_priv *priv = libipw_priv(dev);
9412
9413 mutex_lock(&priv->mutex);
9414 wrqu->retry.disabled = 0;
9415
9416 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
9417 mutex_unlock(&priv->mutex);
9418 return -EINVAL;
9419 }
9420
9421 if (wrqu->retry.flags & IW_RETRY_LONG) {
9422 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
9423 wrqu->retry.value = priv->long_retry_limit;
9424 } else if (wrqu->retry.flags & IW_RETRY_SHORT) {
9425 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
9426 wrqu->retry.value = priv->short_retry_limit;
9427 } else {
9428 wrqu->retry.flags = IW_RETRY_LIMIT;
9429 wrqu->retry.value = priv->short_retry_limit;
9430 }
9431 mutex_unlock(&priv->mutex);
9432
9433 IPW_DEBUG_WX("GET retry -> %d\n", wrqu->retry.value);
9434
9435 return 0;
9436 }
9437
9438 static int ipw_wx_set_scan(struct net_device *dev,
9439 struct iw_request_info *info,
9440 union iwreq_data *wrqu, char *extra)
9441 {
9442 struct ipw_priv *priv = libipw_priv(dev);
9443 struct iw_scan_req *req = (struct iw_scan_req *)extra;
9444 struct delayed_work *work = NULL;
9445
9446 mutex_lock(&priv->mutex);
9447
9448 priv->user_requested_scan = 1;
9449
9450 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
9451 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9452 int len = min((int)req->essid_len,
9453 (int)sizeof(priv->direct_scan_ssid));
9454 memcpy(priv->direct_scan_ssid, req->essid, len);
9455 priv->direct_scan_ssid_len = len;
9456 work = &priv->request_direct_scan;
9457 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
9458 work = &priv->request_passive_scan;
9459 }
9460 } else {
9461
9462 work = &priv->request_scan;
9463 }
9464
9465 mutex_unlock(&priv->mutex);
9466
9467 IPW_DEBUG_WX("Start scan\n");
9468
9469 schedule_delayed_work(work, 0);
9470
9471 return 0;
9472 }
9473
9474 static int ipw_wx_get_scan(struct net_device *dev,
9475 struct iw_request_info *info,
9476 union iwreq_data *wrqu, char *extra)
9477 {
9478 struct ipw_priv *priv = libipw_priv(dev);
9479 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
9480 }
9481
9482 static int ipw_wx_set_encode(struct net_device *dev,
9483 struct iw_request_info *info,
9484 union iwreq_data *wrqu, char *key)
9485 {
9486 struct ipw_priv *priv = libipw_priv(dev);
9487 int ret;
9488 u32 cap = priv->capability;
9489
9490 mutex_lock(&priv->mutex);
9491 ret = libipw_wx_set_encode(priv->ieee, info, wrqu, key);
9492
9493
9494
9495 if (cap != priv->capability &&
9496 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9497 priv->status & STATUS_ASSOCIATED)
9498 ipw_disassociate(priv);
9499
9500 mutex_unlock(&priv->mutex);
9501 return ret;
9502 }
9503
9504 static int ipw_wx_get_encode(struct net_device *dev,
9505 struct iw_request_info *info,
9506 union iwreq_data *wrqu, char *key)
9507 {
9508 struct ipw_priv *priv = libipw_priv(dev);
9509 return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
9510 }
9511
9512 static int ipw_wx_set_power(struct net_device *dev,
9513 struct iw_request_info *info,
9514 union iwreq_data *wrqu, char *extra)
9515 {
9516 struct ipw_priv *priv = libipw_priv(dev);
9517 int err;
9518 mutex_lock(&priv->mutex);
9519 if (wrqu->power.disabled) {
9520 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9521 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9522 if (err) {
9523 IPW_DEBUG_WX("failed setting power mode.\n");
9524 mutex_unlock(&priv->mutex);
9525 return err;
9526 }
9527 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9528 mutex_unlock(&priv->mutex);
9529 return 0;
9530 }
9531
9532 switch (wrqu->power.flags & IW_POWER_MODE) {
9533 case IW_POWER_ON:
9534 case IW_POWER_MODE:
9535 case IW_POWER_ALL_R:
9536 break;
9537 default:
9538 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9539 wrqu->power.flags);
9540 mutex_unlock(&priv->mutex);
9541 return -EOPNOTSUPP;
9542 }
9543
9544
9545
9546 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9547 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9548 else
9549 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9550
9551 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9552 if (err) {
9553 IPW_DEBUG_WX("failed setting power mode.\n");
9554 mutex_unlock(&priv->mutex);
9555 return err;
9556 }
9557
9558 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9559 mutex_unlock(&priv->mutex);
9560 return 0;
9561 }
9562
9563 static int ipw_wx_get_power(struct net_device *dev,
9564 struct iw_request_info *info,
9565 union iwreq_data *wrqu, char *extra)
9566 {
9567 struct ipw_priv *priv = libipw_priv(dev);
9568 mutex_lock(&priv->mutex);
9569 if (!(priv->power_mode & IPW_POWER_ENABLED))
9570 wrqu->power.disabled = 1;
9571 else
9572 wrqu->power.disabled = 0;
9573
9574 mutex_unlock(&priv->mutex);
9575 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9576
9577 return 0;
9578 }
9579
9580 static int ipw_wx_set_powermode(struct net_device *dev,
9581 struct iw_request_info *info,
9582 union iwreq_data *wrqu, char *extra)
9583 {
9584 struct ipw_priv *priv = libipw_priv(dev);
9585 int mode = *(int *)extra;
9586 int err;
9587
9588 mutex_lock(&priv->mutex);
9589 if ((mode < 1) || (mode > IPW_POWER_LIMIT))
9590 mode = IPW_POWER_AC;
9591
9592 if (IPW_POWER_LEVEL(priv->power_mode) != mode) {
9593 err = ipw_send_power_mode(priv, mode);
9594 if (err) {
9595 IPW_DEBUG_WX("failed setting power mode.\n");
9596 mutex_unlock(&priv->mutex);
9597 return err;
9598 }
9599 priv->power_mode = IPW_POWER_ENABLED | mode;
9600 }
9601 mutex_unlock(&priv->mutex);
9602 return 0;
9603 }
9604
9605 #define MAX_WX_STRING 80
9606 static int ipw_wx_get_powermode(struct net_device *dev,
9607 struct iw_request_info *info,
9608 union iwreq_data *wrqu, char *extra)
9609 {
9610 struct ipw_priv *priv = libipw_priv(dev);
9611 int level = IPW_POWER_LEVEL(priv->power_mode);
9612 char *p = extra;
9613
9614 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9615
9616 switch (level) {
9617 case IPW_POWER_AC:
9618 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9619 break;
9620 case IPW_POWER_BATTERY:
9621 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9622 break;
9623 default:
9624 p += snprintf(p, MAX_WX_STRING - (p - extra),
9625 "(Timeout %dms, Period %dms)",
9626 timeout_duration[level - 1] / 1000,
9627 period_duration[level - 1] / 1000);
9628 }
9629
9630 if (!(priv->power_mode & IPW_POWER_ENABLED))
9631 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9632
9633 wrqu->data.length = p - extra + 1;
9634
9635 return 0;
9636 }
9637
9638 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9639 struct iw_request_info *info,
9640 union iwreq_data *wrqu, char *extra)
9641 {
9642 struct ipw_priv *priv = libipw_priv(dev);
9643 int mode = *(int *)extra;
9644 u8 band = 0, modulation = 0;
9645
9646 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9647 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9648 return -EINVAL;
9649 }
9650 mutex_lock(&priv->mutex);
9651 if (priv->adapter == IPW_2915ABG) {
9652 priv->ieee->abg_true = 1;
9653 if (mode & IEEE_A) {
9654 band |= LIBIPW_52GHZ_BAND;
9655 modulation |= LIBIPW_OFDM_MODULATION;
9656 } else
9657 priv->ieee->abg_true = 0;
9658 } else {
9659 if (mode & IEEE_A) {
9660 IPW_WARNING("Attempt to set 2200BG into "
9661 "802.11a mode\n");
9662 mutex_unlock(&priv->mutex);
9663 return -EINVAL;
9664 }
9665
9666 priv->ieee->abg_true = 0;
9667 }
9668
9669 if (mode & IEEE_B) {
9670 band |= LIBIPW_24GHZ_BAND;
9671 modulation |= LIBIPW_CCK_MODULATION;
9672 } else
9673 priv->ieee->abg_true = 0;
9674
9675 if (mode & IEEE_G) {
9676 band |= LIBIPW_24GHZ_BAND;
9677 modulation |= LIBIPW_OFDM_MODULATION;
9678 } else
9679 priv->ieee->abg_true = 0;
9680
9681 priv->ieee->mode = mode;
9682 priv->ieee->freq_band = band;
9683 priv->ieee->modulation = modulation;
9684 init_supported_rates(priv, &priv->rates);
9685
9686
9687 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9688 if (!ipw_disassociate(priv)) {
9689 ipw_send_supported_rates(priv, &priv->rates);
9690 ipw_associate(priv);
9691 }
9692
9693
9694 ipw_led_band_on(priv);
9695
9696 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9697 mode & IEEE_A ? 'a' : '.',
9698 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9699 mutex_unlock(&priv->mutex);
9700 return 0;
9701 }
9702
9703 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9704 struct iw_request_info *info,
9705 union iwreq_data *wrqu, char *extra)
9706 {
9707 struct ipw_priv *priv = libipw_priv(dev);
9708 mutex_lock(&priv->mutex);
9709 switch (priv->ieee->mode) {
9710 case IEEE_A:
9711 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9712 break;
9713 case IEEE_B:
9714 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9715 break;
9716 case IEEE_A | IEEE_B:
9717 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9718 break;
9719 case IEEE_G:
9720 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9721 break;
9722 case IEEE_A | IEEE_G:
9723 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9724 break;
9725 case IEEE_B | IEEE_G:
9726 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9727 break;
9728 case IEEE_A | IEEE_B | IEEE_G:
9729 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9730 break;
9731 default:
9732 strncpy(extra, "unknown", MAX_WX_STRING);
9733 break;
9734 }
9735 extra[MAX_WX_STRING - 1] = '\0';
9736
9737 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9738
9739 wrqu->data.length = strlen(extra) + 1;
9740 mutex_unlock(&priv->mutex);
9741
9742 return 0;
9743 }
9744
9745 static int ipw_wx_set_preamble(struct net_device *dev,
9746 struct iw_request_info *info,
9747 union iwreq_data *wrqu, char *extra)
9748 {
9749 struct ipw_priv *priv = libipw_priv(dev);
9750 int mode = *(int *)extra;
9751 mutex_lock(&priv->mutex);
9752
9753 if (mode == 1) {
9754 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9755 priv->config |= CFG_PREAMBLE_LONG;
9756
9757
9758 IPW_DEBUG_ASSOC
9759 ("[re]association triggered due to preamble change.\n");
9760 if (!ipw_disassociate(priv))
9761 ipw_associate(priv);
9762 }
9763 goto done;
9764 }
9765
9766 if (mode == 0) {
9767 priv->config &= ~CFG_PREAMBLE_LONG;
9768 goto done;
9769 }
9770 mutex_unlock(&priv->mutex);
9771 return -EINVAL;
9772
9773 done:
9774 mutex_unlock(&priv->mutex);
9775 return 0;
9776 }
9777
9778 static int ipw_wx_get_preamble(struct net_device *dev,
9779 struct iw_request_info *info,
9780 union iwreq_data *wrqu, char *extra)
9781 {
9782 struct ipw_priv *priv = libipw_priv(dev);
9783 mutex_lock(&priv->mutex);
9784 if (priv->config & CFG_PREAMBLE_LONG)
9785 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9786 else
9787 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9788 mutex_unlock(&priv->mutex);
9789 return 0;
9790 }
9791
9792 #ifdef CONFIG_IPW2200_MONITOR
9793 static int ipw_wx_set_monitor(struct net_device *dev,
9794 struct iw_request_info *info,
9795 union iwreq_data *wrqu, char *extra)
9796 {
9797 struct ipw_priv *priv = libipw_priv(dev);
9798 int *parms = (int *)extra;
9799 int enable = (parms[0] > 0);
9800 mutex_lock(&priv->mutex);
9801 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9802 if (enable) {
9803 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9804 #ifdef CONFIG_IPW2200_RADIOTAP
9805 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9806 #else
9807 priv->net_dev->type = ARPHRD_IEEE80211;
9808 #endif
9809 schedule_work(&priv->adapter_restart);
9810 }
9811
9812 ipw_set_channel(priv, parms[1]);
9813 } else {
9814 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9815 mutex_unlock(&priv->mutex);
9816 return 0;
9817 }
9818 priv->net_dev->type = ARPHRD_ETHER;
9819 schedule_work(&priv->adapter_restart);
9820 }
9821 mutex_unlock(&priv->mutex);
9822 return 0;
9823 }
9824
9825 #endif
9826
9827 static int ipw_wx_reset(struct net_device *dev,
9828 struct iw_request_info *info,
9829 union iwreq_data *wrqu, char *extra)
9830 {
9831 struct ipw_priv *priv = libipw_priv(dev);
9832 IPW_DEBUG_WX("RESET\n");
9833 schedule_work(&priv->adapter_restart);
9834 return 0;
9835 }
9836
9837 static int ipw_wx_sw_reset(struct net_device *dev,
9838 struct iw_request_info *info,
9839 union iwreq_data *wrqu, char *extra)
9840 {
9841 struct ipw_priv *priv = libipw_priv(dev);
9842 union iwreq_data wrqu_sec = {
9843 .encoding = {
9844 .flags = IW_ENCODE_DISABLED,
9845 },
9846 };
9847 int ret;
9848
9849 IPW_DEBUG_WX("SW_RESET\n");
9850
9851 mutex_lock(&priv->mutex);
9852
9853 ret = ipw_sw_reset(priv, 2);
9854 if (!ret) {
9855 free_firmware();
9856 ipw_adapter_restart(priv);
9857 }
9858
9859
9860
9861 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9862
9863 mutex_unlock(&priv->mutex);
9864 libipw_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9865 mutex_lock(&priv->mutex);
9866
9867 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9868
9869 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9870 "reset.\n");
9871 if (!ipw_disassociate(priv))
9872 ipw_associate(priv);
9873 }
9874
9875 mutex_unlock(&priv->mutex);
9876
9877 return 0;
9878 }
9879
9880
9881 static iw_handler ipw_wx_handlers[] = {
9882 IW_HANDLER(SIOCGIWNAME, (iw_handler)cfg80211_wext_giwname),
9883 IW_HANDLER(SIOCSIWFREQ, ipw_wx_set_freq),
9884 IW_HANDLER(SIOCGIWFREQ, ipw_wx_get_freq),
9885 IW_HANDLER(SIOCSIWMODE, ipw_wx_set_mode),
9886 IW_HANDLER(SIOCGIWMODE, ipw_wx_get_mode),
9887 IW_HANDLER(SIOCSIWSENS, ipw_wx_set_sens),
9888 IW_HANDLER(SIOCGIWSENS, ipw_wx_get_sens),
9889 IW_HANDLER(SIOCGIWRANGE, ipw_wx_get_range),
9890 IW_HANDLER(SIOCSIWAP, ipw_wx_set_wap),
9891 IW_HANDLER(SIOCGIWAP, ipw_wx_get_wap),
9892 IW_HANDLER(SIOCSIWSCAN, ipw_wx_set_scan),
9893 IW_HANDLER(SIOCGIWSCAN, ipw_wx_get_scan),
9894 IW_HANDLER(SIOCSIWESSID, ipw_wx_set_essid),
9895 IW_HANDLER(SIOCGIWESSID, ipw_wx_get_essid),
9896 IW_HANDLER(SIOCSIWNICKN, ipw_wx_set_nick),
9897 IW_HANDLER(SIOCGIWNICKN, ipw_wx_get_nick),
9898 IW_HANDLER(SIOCSIWRATE, ipw_wx_set_rate),
9899 IW_HANDLER(SIOCGIWRATE, ipw_wx_get_rate),
9900 IW_HANDLER(SIOCSIWRTS, ipw_wx_set_rts),
9901 IW_HANDLER(SIOCGIWRTS, ipw_wx_get_rts),
9902 IW_HANDLER(SIOCSIWFRAG, ipw_wx_set_frag),
9903 IW_HANDLER(SIOCGIWFRAG, ipw_wx_get_frag),
9904 IW_HANDLER(SIOCSIWTXPOW, ipw_wx_set_txpow),
9905 IW_HANDLER(SIOCGIWTXPOW, ipw_wx_get_txpow),
9906 IW_HANDLER(SIOCSIWRETRY, ipw_wx_set_retry),
9907 IW_HANDLER(SIOCGIWRETRY, ipw_wx_get_retry),
9908 IW_HANDLER(SIOCSIWENCODE, ipw_wx_set_encode),
9909 IW_HANDLER(SIOCGIWENCODE, ipw_wx_get_encode),
9910 IW_HANDLER(SIOCSIWPOWER, ipw_wx_set_power),
9911 IW_HANDLER(SIOCGIWPOWER, ipw_wx_get_power),
9912 IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
9913 IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
9914 IW_HANDLER(SIOCSIWTHRSPY, iw_handler_set_thrspy),
9915 IW_HANDLER(SIOCGIWTHRSPY, iw_handler_get_thrspy),
9916 IW_HANDLER(SIOCSIWGENIE, ipw_wx_set_genie),
9917 IW_HANDLER(SIOCGIWGENIE, ipw_wx_get_genie),
9918 IW_HANDLER(SIOCSIWMLME, ipw_wx_set_mlme),
9919 IW_HANDLER(SIOCSIWAUTH, ipw_wx_set_auth),
9920 IW_HANDLER(SIOCGIWAUTH, ipw_wx_get_auth),
9921 IW_HANDLER(SIOCSIWENCODEEXT, ipw_wx_set_encodeext),
9922 IW_HANDLER(SIOCGIWENCODEEXT, ipw_wx_get_encodeext),
9923 };
9924
9925 enum {
9926 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9927 IPW_PRIV_GET_POWER,
9928 IPW_PRIV_SET_MODE,
9929 IPW_PRIV_GET_MODE,
9930 IPW_PRIV_SET_PREAMBLE,
9931 IPW_PRIV_GET_PREAMBLE,
9932 IPW_PRIV_RESET,
9933 IPW_PRIV_SW_RESET,
9934 #ifdef CONFIG_IPW2200_MONITOR
9935 IPW_PRIV_SET_MONITOR,
9936 #endif
9937 };
9938
9939 static struct iw_priv_args ipw_priv_args[] = {
9940 {
9941 .cmd = IPW_PRIV_SET_POWER,
9942 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9943 .name = "set_power"},
9944 {
9945 .cmd = IPW_PRIV_GET_POWER,
9946 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9947 .name = "get_power"},
9948 {
9949 .cmd = IPW_PRIV_SET_MODE,
9950 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9951 .name = "set_mode"},
9952 {
9953 .cmd = IPW_PRIV_GET_MODE,
9954 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9955 .name = "get_mode"},
9956 {
9957 .cmd = IPW_PRIV_SET_PREAMBLE,
9958 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9959 .name = "set_preamble"},
9960 {
9961 .cmd = IPW_PRIV_GET_PREAMBLE,
9962 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9963 .name = "get_preamble"},
9964 {
9965 IPW_PRIV_RESET,
9966 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9967 {
9968 IPW_PRIV_SW_RESET,
9969 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9970 #ifdef CONFIG_IPW2200_MONITOR
9971 {
9972 IPW_PRIV_SET_MONITOR,
9973 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9974 #endif
9975 };
9976
9977 static iw_handler ipw_priv_handler[] = {
9978 ipw_wx_set_powermode,
9979 ipw_wx_get_powermode,
9980 ipw_wx_set_wireless_mode,
9981 ipw_wx_get_wireless_mode,
9982 ipw_wx_set_preamble,
9983 ipw_wx_get_preamble,
9984 ipw_wx_reset,
9985 ipw_wx_sw_reset,
9986 #ifdef CONFIG_IPW2200_MONITOR
9987 ipw_wx_set_monitor,
9988 #endif
9989 };
9990
9991 static const struct iw_handler_def ipw_wx_handler_def = {
9992 .standard = ipw_wx_handlers,
9993 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9994 .num_private = ARRAY_SIZE(ipw_priv_handler),
9995 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9996 .private = ipw_priv_handler,
9997 .private_args = ipw_priv_args,
9998 .get_wireless_stats = ipw_get_wireless_stats,
9999 };
10000
10001
10002
10003
10004
10005
10006 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
10007 {
10008 struct ipw_priv *priv = libipw_priv(dev);
10009 struct iw_statistics *wstats;
10010
10011 wstats = &priv->wstats;
10012
10013
10014
10015
10016
10017
10018 if (!(priv->status & STATUS_ASSOCIATED)) {
10019 wstats->miss.beacon = 0;
10020 wstats->discard.retries = 0;
10021 wstats->qual.qual = 0;
10022 wstats->qual.level = 0;
10023 wstats->qual.noise = 0;
10024 wstats->qual.updated = 7;
10025 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
10026 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
10027 return wstats;
10028 }
10029
10030 wstats->qual.qual = priv->quality;
10031 wstats->qual.level = priv->exp_avg_rssi;
10032 wstats->qual.noise = priv->exp_avg_noise;
10033 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
10034 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
10035
10036 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
10037 wstats->discard.retries = priv->last_tx_failures;
10038 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
10039
10040
10041
10042
10043
10044 return wstats;
10045 }
10046
10047
10048
10049 static void init_sys_config(struct ipw_sys_config *sys_config)
10050 {
10051 memset(sys_config, 0, sizeof(struct ipw_sys_config));
10052 sys_config->bt_coexistence = 0;
10053 sys_config->answer_broadcast_ssid_probe = 0;
10054 sys_config->accept_all_data_frames = 0;
10055 sys_config->accept_non_directed_frames = 1;
10056 sys_config->exclude_unicast_unencrypted = 0;
10057 sys_config->disable_unicast_decryption = 1;
10058 sys_config->exclude_multicast_unencrypted = 0;
10059 sys_config->disable_multicast_decryption = 1;
10060 if (antenna < CFG_SYS_ANTENNA_BOTH || antenna > CFG_SYS_ANTENNA_B)
10061 antenna = CFG_SYS_ANTENNA_BOTH;
10062 sys_config->antenna_diversity = antenna;
10063 sys_config->pass_crc_to_host = 0;
10064 sys_config->dot11g_auto_detection = 0;
10065 sys_config->enable_cts_to_self = 0;
10066 sys_config->bt_coexist_collision_thr = 0;
10067 sys_config->pass_noise_stats_to_host = 1;
10068 sys_config->silence_threshold = 0x1e;
10069 }
10070
10071 static int ipw_net_open(struct net_device *dev)
10072 {
10073 IPW_DEBUG_INFO("dev->open\n");
10074 netif_start_queue(dev);
10075 return 0;
10076 }
10077
10078 static int ipw_net_stop(struct net_device *dev)
10079 {
10080 IPW_DEBUG_INFO("dev->close\n");
10081 netif_stop_queue(dev);
10082 return 0;
10083 }
10084
10085
10086
10087
10088
10089
10090
10091
10092 static int ipw_tx_skb(struct ipw_priv *priv, struct libipw_txb *txb,
10093 int pri)
10094 {
10095 struct libipw_hdr_3addrqos *hdr = (struct libipw_hdr_3addrqos *)
10096 txb->fragments[0]->data;
10097 int i = 0;
10098 struct tfd_frame *tfd;
10099 #ifdef CONFIG_IPW2200_QOS
10100 int tx_id = ipw_get_tx_queue_number(priv, pri);
10101 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10102 #else
10103 struct clx2_tx_queue *txq = &priv->txq[0];
10104 #endif
10105 struct clx2_queue *q = &txq->q;
10106 u8 id, hdr_len, unicast;
10107 int fc;
10108
10109 if (!(priv->status & STATUS_ASSOCIATED))
10110 goto drop;
10111
10112 hdr_len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
10113 switch (priv->ieee->iw_mode) {
10114 case IW_MODE_ADHOC:
10115 unicast = !is_multicast_ether_addr(hdr->addr1);
10116 id = ipw_find_station(priv, hdr->addr1);
10117 if (id == IPW_INVALID_STATION) {
10118 id = ipw_add_station(priv, hdr->addr1);
10119 if (id == IPW_INVALID_STATION) {
10120 IPW_WARNING("Attempt to send data to "
10121 "invalid cell: %pM\n",
10122 hdr->addr1);
10123 goto drop;
10124 }
10125 }
10126 break;
10127
10128 case IW_MODE_INFRA:
10129 default:
10130 unicast = !is_multicast_ether_addr(hdr->addr3);
10131 id = 0;
10132 break;
10133 }
10134
10135 tfd = &txq->bd[q->first_empty];
10136 txq->txb[q->first_empty] = txb;
10137 memset(tfd, 0, sizeof(*tfd));
10138 tfd->u.data.station_number = id;
10139
10140 tfd->control_flags.message_type = TX_FRAME_TYPE;
10141 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10142
10143 tfd->u.data.cmd_id = DINO_CMD_TX;
10144 tfd->u.data.len = cpu_to_le16(txb->payload_size);
10145
10146 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
10147 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10148 else
10149 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10150
10151 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10152 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10153
10154 fc = le16_to_cpu(hdr->frame_ctl);
10155 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
10156
10157 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10158
10159 if (likely(unicast))
10160 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10161
10162 if (txb->encrypted && !priv->ieee->host_encrypt) {
10163 switch (priv->ieee->sec.level) {
10164 case SEC_LEVEL_3:
10165 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10166 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10167
10168
10169
10170
10171 if (!unicast)
10172 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10173
10174 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10175 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10176 tfd->u.data.key_index = 0;
10177 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10178 break;
10179 case SEC_LEVEL_2:
10180 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10181 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10182 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10183 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10184 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10185 break;
10186 case SEC_LEVEL_1:
10187 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10188 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10189 tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10190 if (priv->ieee->sec.key_sizes[priv->ieee->crypt_info.tx_keyidx] <=
10191 40)
10192 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10193 else
10194 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10195 break;
10196 case SEC_LEVEL_0:
10197 break;
10198 default:
10199 printk(KERN_ERR "Unknown security level %d\n",
10200 priv->ieee->sec.level);
10201 break;
10202 }
10203 } else
10204
10205 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10206
10207 #ifdef CONFIG_IPW2200_QOS
10208 if (fc & IEEE80211_STYPE_QOS_DATA)
10209 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
10210 #endif
10211
10212
10213 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10214 txb->nr_frags));
10215 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10216 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10217 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10218 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10219 i, le32_to_cpu(tfd->u.data.num_chunks),
10220 txb->fragments[i]->len - hdr_len);
10221 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
10222 i, tfd->u.data.num_chunks,
10223 txb->fragments[i]->len - hdr_len);
10224 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10225 txb->fragments[i]->len - hdr_len);
10226
10227 tfd->u.data.chunk_ptr[i] =
10228 cpu_to_le32(pci_map_single
10229 (priv->pci_dev,
10230 txb->fragments[i]->data + hdr_len,
10231 txb->fragments[i]->len - hdr_len,
10232 PCI_DMA_TODEVICE));
10233 tfd->u.data.chunk_len[i] =
10234 cpu_to_le16(txb->fragments[i]->len - hdr_len);
10235 }
10236
10237 if (i != txb->nr_frags) {
10238 struct sk_buff *skb;
10239 u16 remaining_bytes = 0;
10240 int j;
10241
10242 for (j = i; j < txb->nr_frags; j++)
10243 remaining_bytes += txb->fragments[j]->len - hdr_len;
10244
10245 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10246 remaining_bytes);
10247 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10248 if (skb != NULL) {
10249 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10250 for (j = i; j < txb->nr_frags; j++) {
10251 int size = txb->fragments[j]->len - hdr_len;
10252
10253 printk(KERN_INFO "Adding frag %d %d...\n",
10254 j, size);
10255 skb_put_data(skb,
10256 txb->fragments[j]->data + hdr_len,
10257 size);
10258 }
10259 dev_kfree_skb_any(txb->fragments[i]);
10260 txb->fragments[i] = skb;
10261 tfd->u.data.chunk_ptr[i] =
10262 cpu_to_le32(pci_map_single
10263 (priv->pci_dev, skb->data,
10264 remaining_bytes,
10265 PCI_DMA_TODEVICE));
10266
10267 le32_add_cpu(&tfd->u.data.num_chunks, 1);
10268 }
10269 }
10270
10271
10272 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10273 ipw_write32(priv, q->reg_w, q->first_empty);
10274
10275 if (ipw_tx_queue_space(q) < q->high_mark)
10276 netif_stop_queue(priv->net_dev);
10277
10278 return NETDEV_TX_OK;
10279
10280 drop:
10281 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
10282 libipw_txb_free(txb);
10283 return NETDEV_TX_OK;
10284 }
10285
10286 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10287 {
10288 struct ipw_priv *priv = libipw_priv(dev);
10289 #ifdef CONFIG_IPW2200_QOS
10290 int tx_id = ipw_get_tx_queue_number(priv, pri);
10291 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10292 #else
10293 struct clx2_tx_queue *txq = &priv->txq[0];
10294 #endif
10295
10296 if (ipw_tx_queue_space(&txq->q) < txq->q.high_mark)
10297 return 1;
10298
10299 return 0;
10300 }
10301
10302 #ifdef CONFIG_IPW2200_PROMISCUOUS
10303 static void ipw_handle_promiscuous_tx(struct ipw_priv *priv,
10304 struct libipw_txb *txb)
10305 {
10306 struct libipw_rx_stats dummystats;
10307 struct ieee80211_hdr *hdr;
10308 u8 n;
10309 u16 filter = priv->prom_priv->filter;
10310 int hdr_only = 0;
10311
10312 if (filter & IPW_PROM_NO_TX)
10313 return;
10314
10315 memset(&dummystats, 0, sizeof(dummystats));
10316
10317
10318 hdr = (void *)txb->fragments[0]->data;
10319 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
10320 if (filter & IPW_PROM_NO_MGMT)
10321 return;
10322 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
10323 hdr_only = 1;
10324 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
10325 if (filter & IPW_PROM_NO_CTL)
10326 return;
10327 if (filter & IPW_PROM_CTL_HEADER_ONLY)
10328 hdr_only = 1;
10329 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
10330 if (filter & IPW_PROM_NO_DATA)
10331 return;
10332 if (filter & IPW_PROM_DATA_HEADER_ONLY)
10333 hdr_only = 1;
10334 }
10335
10336 for(n=0; n<txb->nr_frags; ++n) {
10337 struct sk_buff *src = txb->fragments[n];
10338 struct sk_buff *dst;
10339 struct ieee80211_radiotap_header *rt_hdr;
10340 int len;
10341
10342 if (hdr_only) {
10343 hdr = (void *)src->data;
10344 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
10345 } else
10346 len = src->len;
10347
10348 dst = alloc_skb(len + sizeof(*rt_hdr) + sizeof(u16)*2, GFP_ATOMIC);
10349 if (!dst)
10350 continue;
10351
10352 rt_hdr = skb_put(dst, sizeof(*rt_hdr));
10353
10354 rt_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
10355 rt_hdr->it_pad = 0;
10356 rt_hdr->it_present = 0;
10357 rt_hdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
10358
10359 *(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
10360 ieee80211chan2mhz(priv->channel));
10361 if (priv->channel > 14)
10362 *(__le16*)skb_put(dst, sizeof(u16)) =
10363 cpu_to_le16(IEEE80211_CHAN_OFDM |
10364 IEEE80211_CHAN_5GHZ);
10365 else if (priv->ieee->mode == IEEE_B)
10366 *(__le16*)skb_put(dst, sizeof(u16)) =
10367 cpu_to_le16(IEEE80211_CHAN_CCK |
10368 IEEE80211_CHAN_2GHZ);
10369 else
10370 *(__le16*)skb_put(dst, sizeof(u16)) =
10371 cpu_to_le16(IEEE80211_CHAN_OFDM |
10372 IEEE80211_CHAN_2GHZ);
10373
10374 rt_hdr->it_len = cpu_to_le16(dst->len);
10375
10376 skb_copy_from_linear_data(src, skb_put(dst, len), len);
10377
10378 if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))
10379 dev_kfree_skb_any(dst);
10380 }
10381 }
10382 #endif
10383
10384 static netdev_tx_t ipw_net_hard_start_xmit(struct libipw_txb *txb,
10385 struct net_device *dev, int pri)
10386 {
10387 struct ipw_priv *priv = libipw_priv(dev);
10388 unsigned long flags;
10389 netdev_tx_t ret;
10390
10391 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
10392 spin_lock_irqsave(&priv->lock, flags);
10393
10394 #ifdef CONFIG_IPW2200_PROMISCUOUS
10395 if (rtap_iface && netif_running(priv->prom_net_dev))
10396 ipw_handle_promiscuous_tx(priv, txb);
10397 #endif
10398
10399 ret = ipw_tx_skb(priv, txb, pri);
10400 if (ret == NETDEV_TX_OK)
10401 __ipw_led_activity_on(priv);
10402 spin_unlock_irqrestore(&priv->lock, flags);
10403
10404 return ret;
10405 }
10406
10407 static void ipw_net_set_multicast_list(struct net_device *dev)
10408 {
10409
10410 }
10411
10412 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10413 {
10414 struct ipw_priv *priv = libipw_priv(dev);
10415 struct sockaddr *addr = p;
10416
10417 if (!is_valid_ether_addr(addr->sa_data))
10418 return -EADDRNOTAVAIL;
10419 mutex_lock(&priv->mutex);
10420 priv->config |= CFG_CUSTOM_MAC;
10421 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
10422 printk(KERN_INFO "%s: Setting MAC to %pM\n",
10423 priv->net_dev->name, priv->mac_addr);
10424 schedule_work(&priv->adapter_restart);
10425 mutex_unlock(&priv->mutex);
10426 return 0;
10427 }
10428
10429 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
10430 struct ethtool_drvinfo *info)
10431 {
10432 struct ipw_priv *p = libipw_priv(dev);
10433 char vers[64];
10434 char date[32];
10435 u32 len;
10436
10437 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
10438 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
10439
10440 len = sizeof(vers);
10441 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10442 len = sizeof(date);
10443 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
10444
10445 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
10446 vers, date);
10447 strlcpy(info->bus_info, pci_name(p->pci_dev),
10448 sizeof(info->bus_info));
10449 }
10450
10451 static u32 ipw_ethtool_get_link(struct net_device *dev)
10452 {
10453 struct ipw_priv *priv = libipw_priv(dev);
10454 return (priv->status & STATUS_ASSOCIATED) != 0;
10455 }
10456
10457 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10458 {
10459 return IPW_EEPROM_IMAGE_SIZE;
10460 }
10461
10462 static int ipw_ethtool_get_eeprom(struct net_device *dev,
10463 struct ethtool_eeprom *eeprom, u8 * bytes)
10464 {
10465 struct ipw_priv *p = libipw_priv(dev);
10466
10467 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10468 return -EINVAL;
10469 mutex_lock(&p->mutex);
10470 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10471 mutex_unlock(&p->mutex);
10472 return 0;
10473 }
10474
10475 static int ipw_ethtool_set_eeprom(struct net_device *dev,
10476 struct ethtool_eeprom *eeprom, u8 * bytes)
10477 {
10478 struct ipw_priv *p = libipw_priv(dev);
10479 int i;
10480
10481 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10482 return -EINVAL;
10483 mutex_lock(&p->mutex);
10484 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10485 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
10486 ipw_write8(p, i + IPW_EEPROM_DATA, p->eeprom[i]);
10487 mutex_unlock(&p->mutex);
10488 return 0;
10489 }
10490
10491 static const struct ethtool_ops ipw_ethtool_ops = {
10492 .get_link = ipw_ethtool_get_link,
10493 .get_drvinfo = ipw_ethtool_get_drvinfo,
10494 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10495 .get_eeprom = ipw_ethtool_get_eeprom,
10496 .set_eeprom = ipw_ethtool_set_eeprom,
10497 };
10498
10499 static irqreturn_t ipw_isr(int irq, void *data)
10500 {
10501 struct ipw_priv *priv = data;
10502 u32 inta, inta_mask;
10503
10504 if (!priv)
10505 return IRQ_NONE;
10506
10507 spin_lock(&priv->irq_lock);
10508
10509 if (!(priv->status & STATUS_INT_ENABLED)) {
10510
10511 goto none;
10512 }
10513
10514 inta = ipw_read32(priv, IPW_INTA_RW);
10515 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
10516
10517 if (inta == 0xFFFFFFFF) {
10518
10519 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10520 goto none;
10521 }
10522
10523 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10524
10525 goto none;
10526 }
10527
10528
10529 __ipw_disable_interrupts(priv);
10530
10531
10532 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10533 ipw_write32(priv, IPW_INTA_RW, inta);
10534
10535
10536 priv->isr_inta = inta;
10537
10538 tasklet_schedule(&priv->irq_tasklet);
10539
10540 spin_unlock(&priv->irq_lock);
10541
10542 return IRQ_HANDLED;
10543 none:
10544 spin_unlock(&priv->irq_lock);
10545 return IRQ_NONE;
10546 }
10547
10548 static void ipw_rf_kill(void *adapter)
10549 {
10550 struct ipw_priv *priv = adapter;
10551 unsigned long flags;
10552
10553 spin_lock_irqsave(&priv->lock, flags);
10554
10555 if (rf_kill_active(priv)) {
10556 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10557 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
10558 goto exit_unlock;
10559 }
10560
10561
10562
10563 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10564 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10565 "device\n");
10566
10567
10568 schedule_work(&priv->adapter_restart);
10569 } else
10570 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10571 "enabled\n");
10572
10573 exit_unlock:
10574 spin_unlock_irqrestore(&priv->lock, flags);
10575 }
10576
10577 static void ipw_bg_rf_kill(struct work_struct *work)
10578 {
10579 struct ipw_priv *priv =
10580 container_of(work, struct ipw_priv, rf_kill.work);
10581 mutex_lock(&priv->mutex);
10582 ipw_rf_kill(priv);
10583 mutex_unlock(&priv->mutex);
10584 }
10585
10586 static void ipw_link_up(struct ipw_priv *priv)
10587 {
10588 priv->last_seq_num = -1;
10589 priv->last_frag_num = -1;
10590 priv->last_packet_time = 0;
10591
10592 netif_carrier_on(priv->net_dev);
10593
10594 cancel_delayed_work(&priv->request_scan);
10595 cancel_delayed_work(&priv->request_direct_scan);
10596 cancel_delayed_work(&priv->request_passive_scan);
10597 cancel_delayed_work(&priv->scan_event);
10598 ipw_reset_stats(priv);
10599
10600 priv->last_rate = ipw_get_current_rate(priv);
10601 ipw_gather_stats(priv);
10602 ipw_led_link_up(priv);
10603 notify_wx_assoc_event(priv);
10604
10605 if (priv->config & CFG_BACKGROUND_SCAN)
10606 schedule_delayed_work(&priv->request_scan, HZ);
10607 }
10608
10609 static void ipw_bg_link_up(struct work_struct *work)
10610 {
10611 struct ipw_priv *priv =
10612 container_of(work, struct ipw_priv, link_up);
10613 mutex_lock(&priv->mutex);
10614 ipw_link_up(priv);
10615 mutex_unlock(&priv->mutex);
10616 }
10617
10618 static void ipw_link_down(struct ipw_priv *priv)
10619 {
10620 ipw_led_link_down(priv);
10621 netif_carrier_off(priv->net_dev);
10622 notify_wx_assoc_event(priv);
10623
10624
10625 cancel_delayed_work(&priv->request_scan);
10626 cancel_delayed_work(&priv->request_direct_scan);
10627 cancel_delayed_work(&priv->request_passive_scan);
10628 cancel_delayed_work(&priv->adhoc_check);
10629 cancel_delayed_work(&priv->gather_stats);
10630
10631 ipw_reset_stats(priv);
10632
10633 if (!(priv->status & STATUS_EXIT_PENDING)) {
10634
10635 schedule_delayed_work(&priv->request_scan, 0);
10636 } else
10637 cancel_delayed_work(&priv->scan_event);
10638 }
10639
10640 static void ipw_bg_link_down(struct work_struct *work)
10641 {
10642 struct ipw_priv *priv =
10643 container_of(work, struct ipw_priv, link_down);
10644 mutex_lock(&priv->mutex);
10645 ipw_link_down(priv);
10646 mutex_unlock(&priv->mutex);
10647 }
10648
10649 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10650 {
10651 int ret = 0;
10652
10653 init_waitqueue_head(&priv->wait_command_queue);
10654 init_waitqueue_head(&priv->wait_state);
10655
10656 INIT_DELAYED_WORK(&priv->adhoc_check, ipw_bg_adhoc_check);
10657 INIT_WORK(&priv->associate, ipw_bg_associate);
10658 INIT_WORK(&priv->disassociate, ipw_bg_disassociate);
10659 INIT_WORK(&priv->system_config, ipw_system_config);
10660 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish);
10661 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart);
10662 INIT_DELAYED_WORK(&priv->rf_kill, ipw_bg_rf_kill);
10663 INIT_WORK(&priv->up, ipw_bg_up);
10664 INIT_WORK(&priv->down, ipw_bg_down);
10665 INIT_DELAYED_WORK(&priv->request_scan, ipw_request_scan);
10666 INIT_DELAYED_WORK(&priv->request_direct_scan, ipw_request_direct_scan);
10667 INIT_DELAYED_WORK(&priv->request_passive_scan, ipw_request_passive_scan);
10668 INIT_DELAYED_WORK(&priv->scan_event, ipw_scan_event);
10669 INIT_DELAYED_WORK(&priv->gather_stats, ipw_bg_gather_stats);
10670 INIT_WORK(&priv->abort_scan, ipw_bg_abort_scan);
10671 INIT_WORK(&priv->roam, ipw_bg_roam);
10672 INIT_DELAYED_WORK(&priv->scan_check, ipw_bg_scan_check);
10673 INIT_WORK(&priv->link_up, ipw_bg_link_up);
10674 INIT_WORK(&priv->link_down, ipw_bg_link_down);
10675 INIT_DELAYED_WORK(&priv->led_link_on, ipw_bg_led_link_on);
10676 INIT_DELAYED_WORK(&priv->led_link_off, ipw_bg_led_link_off);
10677 INIT_DELAYED_WORK(&priv->led_act_off, ipw_bg_led_activity_off);
10678 INIT_WORK(&priv->merge_networks, ipw_merge_adhoc_network);
10679
10680 #ifdef CONFIG_IPW2200_QOS
10681 INIT_WORK(&priv->qos_activate, ipw_bg_qos_activate);
10682 #endif
10683
10684 tasklet_init(&priv->irq_tasklet,
10685 ipw_irq_tasklet, (unsigned long)priv);
10686
10687 return ret;
10688 }
10689
10690 static void shim__set_security(struct net_device *dev,
10691 struct libipw_security *sec)
10692 {
10693 struct ipw_priv *priv = libipw_priv(dev);
10694 int i;
10695 for (i = 0; i < 4; i++) {
10696 if (sec->flags & (1 << i)) {
10697 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10698 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10699 if (sec->key_sizes[i] == 0)
10700 priv->ieee->sec.flags &= ~(1 << i);
10701 else {
10702 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10703 sec->key_sizes[i]);
10704 priv->ieee->sec.flags |= (1 << i);
10705 }
10706 priv->status |= STATUS_SECURITY_UPDATED;
10707 } else if (sec->level != SEC_LEVEL_1)
10708 priv->ieee->sec.flags &= ~(1 << i);
10709 }
10710
10711 if (sec->flags & SEC_ACTIVE_KEY) {
10712 priv->ieee->sec.active_key = sec->active_key;
10713 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10714 priv->status |= STATUS_SECURITY_UPDATED;
10715 } else
10716 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10717
10718 if ((sec->flags & SEC_AUTH_MODE) &&
10719 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10720 priv->ieee->sec.auth_mode = sec->auth_mode;
10721 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10722 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10723 priv->capability |= CAP_SHARED_KEY;
10724 else
10725 priv->capability &= ~CAP_SHARED_KEY;
10726 priv->status |= STATUS_SECURITY_UPDATED;
10727 }
10728
10729 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10730 priv->ieee->sec.flags |= SEC_ENABLED;
10731 priv->ieee->sec.enabled = sec->enabled;
10732 priv->status |= STATUS_SECURITY_UPDATED;
10733 if (sec->enabled)
10734 priv->capability |= CAP_PRIVACY_ON;
10735 else
10736 priv->capability &= ~CAP_PRIVACY_ON;
10737 }
10738
10739 if (sec->flags & SEC_ENCRYPT)
10740 priv->ieee->sec.encrypt = sec->encrypt;
10741
10742 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10743 priv->ieee->sec.level = sec->level;
10744 priv->ieee->sec.flags |= SEC_LEVEL;
10745 priv->status |= STATUS_SECURITY_UPDATED;
10746 }
10747
10748 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10749 ipw_set_hwcrypto_keys(priv);
10750
10751
10752
10753
10754 #if 0
10755 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10756 (((priv->assoc_request.capability &
10757 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && !sec->enabled) ||
10758 (!(priv->assoc_request.capability &
10759 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && sec->enabled))) {
10760 IPW_DEBUG_ASSOC("Disassociating due to capability "
10761 "change.\n");
10762 ipw_disassociate(priv);
10763 }
10764 #endif
10765 }
10766
10767 static int init_supported_rates(struct ipw_priv *priv,
10768 struct ipw_supported_rates *rates)
10769 {
10770
10771
10772 memset(rates, 0, sizeof(*rates));
10773
10774 switch (priv->ieee->freq_band) {
10775 case LIBIPW_52GHZ_BAND:
10776 rates->ieee_mode = IPW_A_MODE;
10777 rates->purpose = IPW_RATE_CAPABILITIES;
10778 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10779 LIBIPW_OFDM_DEFAULT_RATES_MASK);
10780 break;
10781
10782 default:
10783 rates->ieee_mode = IPW_G_MODE;
10784 rates->purpose = IPW_RATE_CAPABILITIES;
10785 ipw_add_cck_scan_rates(rates, LIBIPW_CCK_MODULATION,
10786 LIBIPW_CCK_DEFAULT_RATES_MASK);
10787 if (priv->ieee->modulation & LIBIPW_OFDM_MODULATION) {
10788 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10789 LIBIPW_OFDM_DEFAULT_RATES_MASK);
10790 }
10791 break;
10792 }
10793
10794 return 0;
10795 }
10796
10797 static int ipw_config(struct ipw_priv *priv)
10798 {
10799
10800
10801
10802 if (ipw_set_tx_power(priv))
10803 goto error;
10804
10805
10806 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10807 goto error;
10808
10809
10810 init_sys_config(&priv->sys_config);
10811
10812
10813
10814 if (bt_coexist) {
10815 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10816
10817 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10818 priv->sys_config.bt_coexistence
10819 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10820 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10821 priv->sys_config.bt_coexistence
10822 |= CFG_BT_COEXISTENCE_OOB;
10823 }
10824
10825 #ifdef CONFIG_IPW2200_PROMISCUOUS
10826 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
10827 priv->sys_config.accept_all_data_frames = 1;
10828 priv->sys_config.accept_non_directed_frames = 1;
10829 priv->sys_config.accept_all_mgmt_bcpr = 1;
10830 priv->sys_config.accept_all_mgmt_frames = 1;
10831 }
10832 #endif
10833
10834 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10835 priv->sys_config.answer_broadcast_ssid_probe = 1;
10836 else
10837 priv->sys_config.answer_broadcast_ssid_probe = 0;
10838
10839 if (ipw_send_system_config(priv))
10840 goto error;
10841
10842 init_supported_rates(priv, &priv->rates);
10843 if (ipw_send_supported_rates(priv, &priv->rates))
10844 goto error;
10845
10846
10847 if (priv->rts_threshold) {
10848 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10849 goto error;
10850 }
10851 #ifdef CONFIG_IPW2200_QOS
10852 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10853 ipw_qos_activate(priv, NULL);
10854 #endif
10855
10856 if (ipw_set_random_seed(priv))
10857 goto error;
10858
10859
10860 if (ipw_send_host_complete(priv))
10861 goto error;
10862
10863 priv->status |= STATUS_INIT;
10864
10865 ipw_led_init(priv);
10866 ipw_led_radio_on(priv);
10867 priv->notif_missed_beacons = 0;
10868
10869
10870 if ((priv->capability & CAP_PRIVACY_ON) &&
10871 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10872 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10873 ipw_set_hwcrypto_keys(priv);
10874
10875 return 0;
10876
10877 error:
10878 return -EIO;
10879 }
10880
10881
10882
10883
10884
10885
10886
10887
10888
10889
10890
10891
10892
10893
10894
10895 static const struct libipw_geo ipw_geos[] = {
10896 {
10897 "---",
10898 .bg_channels = 11,
10899 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10900 {2427, 4}, {2432, 5}, {2437, 6},
10901 {2442, 7}, {2447, 8}, {2452, 9},
10902 {2457, 10}, {2462, 11}},
10903 },
10904
10905 {
10906 "ZZF",
10907 .bg_channels = 11,
10908 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10909 {2427, 4}, {2432, 5}, {2437, 6},
10910 {2442, 7}, {2447, 8}, {2452, 9},
10911 {2457, 10}, {2462, 11}},
10912 .a_channels = 8,
10913 .a = {{5180, 36},
10914 {5200, 40},
10915 {5220, 44},
10916 {5240, 48},
10917 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
10918 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
10919 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
10920 {5320, 64, LIBIPW_CH_PASSIVE_ONLY}},
10921 },
10922
10923 {
10924 "ZZD",
10925 .bg_channels = 13,
10926 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10927 {2427, 4}, {2432, 5}, {2437, 6},
10928 {2442, 7}, {2447, 8}, {2452, 9},
10929 {2457, 10}, {2462, 11}, {2467, 12},
10930 {2472, 13}},
10931 },
10932
10933 {
10934 "ZZA",
10935 .bg_channels = 11,
10936 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10937 {2427, 4}, {2432, 5}, {2437, 6},
10938 {2442, 7}, {2447, 8}, {2452, 9},
10939 {2457, 10}, {2462, 11}},
10940 .a_channels = 13,
10941 .a = {{5180, 36},
10942 {5200, 40},
10943 {5220, 44},
10944 {5240, 48},
10945 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
10946 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
10947 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
10948 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
10949 {5745, 149},
10950 {5765, 153},
10951 {5785, 157},
10952 {5805, 161},
10953 {5825, 165}},
10954 },
10955
10956 {
10957 "ZZB",
10958 .bg_channels = 11,
10959 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10960 {2427, 4}, {2432, 5}, {2437, 6},
10961 {2442, 7}, {2447, 8}, {2452, 9},
10962 {2457, 10}, {2462, 11}},
10963 .a_channels = 13,
10964 .a = {{5180, 36},
10965 {5200, 40},
10966 {5220, 44},
10967 {5240, 48},
10968 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
10969 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
10970 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
10971 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
10972 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
10973 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
10974 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
10975 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
10976 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
10977 },
10978
10979 {
10980 "ZZC",
10981 .bg_channels = 11,
10982 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10983 {2427, 4}, {2432, 5}, {2437, 6},
10984 {2442, 7}, {2447, 8}, {2452, 9},
10985 {2457, 10}, {2462, 11}},
10986 .a_channels = 4,
10987 .a = {{5170, 34}, {5190, 38},
10988 {5210, 42}, {5230, 46}},
10989 },
10990
10991 {
10992 "ZZM",
10993 .bg_channels = 11,
10994 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10995 {2427, 4}, {2432, 5}, {2437, 6},
10996 {2442, 7}, {2447, 8}, {2452, 9},
10997 {2457, 10}, {2462, 11}},
10998 },
10999
11000 {
11001 "ZZE",
11002 .bg_channels = 13,
11003 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11004 {2427, 4}, {2432, 5}, {2437, 6},
11005 {2442, 7}, {2447, 8}, {2452, 9},
11006 {2457, 10}, {2462, 11}, {2467, 12},
11007 {2472, 13}},
11008 .a_channels = 19,
11009 .a = {{5180, 36},
11010 {5200, 40},
11011 {5220, 44},
11012 {5240, 48},
11013 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11014 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11015 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11016 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11017 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11018 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11019 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11020 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11021 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11022 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11023 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11024 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11025 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11026 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11027 {5700, 140, LIBIPW_CH_PASSIVE_ONLY}},
11028 },
11029
11030 {
11031 "ZZJ",
11032 .bg_channels = 14,
11033 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11034 {2427, 4}, {2432, 5}, {2437, 6},
11035 {2442, 7}, {2447, 8}, {2452, 9},
11036 {2457, 10}, {2462, 11}, {2467, 12},
11037 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY}},
11038 .a_channels = 4,
11039 .a = {{5170, 34}, {5190, 38},
11040 {5210, 42}, {5230, 46}},
11041 },
11042
11043 {
11044 "ZZR",
11045 .bg_channels = 14,
11046 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11047 {2427, 4}, {2432, 5}, {2437, 6},
11048 {2442, 7}, {2447, 8}, {2452, 9},
11049 {2457, 10}, {2462, 11}, {2467, 12},
11050 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY |
11051 LIBIPW_CH_PASSIVE_ONLY}},
11052 },
11053
11054 {
11055 "ZZH",
11056 .bg_channels = 13,
11057 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11058 {2427, 4}, {2432, 5}, {2437, 6},
11059 {2442, 7}, {2447, 8}, {2452, 9},
11060 {2457, 10}, {2462, 11},
11061 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11062 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
11063 .a_channels = 4,
11064 .a = {{5745, 149}, {5765, 153},
11065 {5785, 157}, {5805, 161}},
11066 },
11067
11068 {
11069 "ZZG",
11070 .bg_channels = 13,
11071 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11072 {2427, 4}, {2432, 5}, {2437, 6},
11073 {2442, 7}, {2447, 8}, {2452, 9},
11074 {2457, 10}, {2462, 11},
11075 {2467, 12}, {2472, 13}},
11076 .a_channels = 4,
11077 .a = {{5180, 36}, {5200, 40},
11078 {5220, 44}, {5240, 48}},
11079 },
11080
11081 {
11082 "ZZK",
11083 .bg_channels = 13,
11084 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11085 {2427, 4}, {2432, 5}, {2437, 6},
11086 {2442, 7}, {2447, 8}, {2452, 9},
11087 {2457, 10}, {2462, 11},
11088 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11089 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
11090 .a_channels = 24,
11091 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11092 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11093 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11094 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11095 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11096 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11097 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11098 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11099 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11100 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11101 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11102 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11103 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11104 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11105 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11106 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11107 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11108 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11109 {5700, 140, LIBIPW_CH_PASSIVE_ONLY},
11110 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11111 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11112 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11113 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11114 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
11115 },
11116
11117 {
11118 "ZZL",
11119 .bg_channels = 11,
11120 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11121 {2427, 4}, {2432, 5}, {2437, 6},
11122 {2442, 7}, {2447, 8}, {2452, 9},
11123 {2457, 10}, {2462, 11}},
11124 .a_channels = 13,
11125 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11126 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11127 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11128 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11129 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11130 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11131 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11132 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11133 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11134 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11135 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11136 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11137 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
11138 }
11139 };
11140
11141 static void ipw_set_geo(struct ipw_priv *priv)
11142 {
11143 int j;
11144
11145 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11146 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11147 ipw_geos[j].name, 3))
11148 break;
11149 }
11150
11151 if (j == ARRAY_SIZE(ipw_geos)) {
11152 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
11153 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
11154 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
11155 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
11156 j = 0;
11157 }
11158
11159 libipw_set_geo(priv->ieee, &ipw_geos[j]);
11160 }
11161
11162 #define MAX_HW_RESTARTS 5
11163 static int ipw_up(struct ipw_priv *priv)
11164 {
11165 int rc, i;
11166
11167
11168 if (priv->suspend_time) {
11169 libipw_networks_age(priv->ieee, priv->suspend_time);
11170 priv->suspend_time = 0;
11171 }
11172
11173 if (priv->status & STATUS_EXIT_PENDING)
11174 return -EIO;
11175
11176 if (cmdlog && !priv->cmdlog) {
11177 priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
11178 GFP_KERNEL);
11179 if (priv->cmdlog == NULL) {
11180 IPW_ERROR("Error allocating %d command log entries.\n",
11181 cmdlog);
11182 return -ENOMEM;
11183 } else {
11184 priv->cmdlog_len = cmdlog;
11185 }
11186 }
11187
11188 for (i = 0; i < MAX_HW_RESTARTS; i++) {
11189
11190
11191 rc = ipw_load(priv);
11192 if (rc) {
11193 IPW_ERROR("Unable to load firmware: %d\n", rc);
11194 return rc;
11195 }
11196
11197 ipw_init_ordinals(priv);
11198 if (!(priv->config & CFG_CUSTOM_MAC))
11199 eeprom_parse_mac(priv, priv->mac_addr);
11200 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
11201
11202 ipw_set_geo(priv);
11203
11204 if (priv->status & STATUS_RF_KILL_SW) {
11205 IPW_WARNING("Radio disabled by module parameter.\n");
11206 return 0;
11207 } else if (rf_kill_active(priv)) {
11208 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11209 "Kill switch must be turned off for "
11210 "wireless networking to work.\n");
11211 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
11212 return 0;
11213 }
11214
11215 rc = ipw_config(priv);
11216 if (!rc) {
11217 IPW_DEBUG_INFO("Configured device on count %i\n", i);
11218
11219
11220
11221 schedule_delayed_work(&priv->request_scan, 0);
11222
11223 return 0;
11224 }
11225
11226 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
11227 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11228 i, MAX_HW_RESTARTS);
11229
11230
11231
11232 ipw_down(priv);
11233 }
11234
11235
11236
11237 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
11238
11239 return -EIO;
11240 }
11241
11242 static void ipw_bg_up(struct work_struct *work)
11243 {
11244 struct ipw_priv *priv =
11245 container_of(work, struct ipw_priv, up);
11246 mutex_lock(&priv->mutex);
11247 ipw_up(priv);
11248 mutex_unlock(&priv->mutex);
11249 }
11250
11251 static void ipw_deinit(struct ipw_priv *priv)
11252 {
11253 int i;
11254
11255 if (priv->status & STATUS_SCANNING) {
11256 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11257 ipw_abort_scan(priv);
11258 }
11259
11260 if (priv->status & STATUS_ASSOCIATED) {
11261 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11262 ipw_disassociate(priv);
11263 }
11264
11265 ipw_led_shutdown(priv);
11266
11267
11268
11269
11270 for (i = 1000; i && (priv->status &
11271 (STATUS_DISASSOCIATING |
11272 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11273 udelay(10);
11274
11275 if (priv->status & (STATUS_DISASSOCIATING |
11276 STATUS_ASSOCIATED | STATUS_SCANNING))
11277 IPW_DEBUG_INFO("Still associated or scanning...\n");
11278 else
11279 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11280
11281
11282 ipw_send_card_disable(priv, 0);
11283
11284 priv->status &= ~STATUS_INIT;
11285 }
11286
11287 static void ipw_down(struct ipw_priv *priv)
11288 {
11289 int exit_pending = priv->status & STATUS_EXIT_PENDING;
11290
11291 priv->status |= STATUS_EXIT_PENDING;
11292
11293 if (ipw_is_init(priv))
11294 ipw_deinit(priv);
11295
11296
11297
11298 if (!exit_pending)
11299 priv->status &= ~STATUS_EXIT_PENDING;
11300
11301
11302 ipw_disable_interrupts(priv);
11303
11304
11305 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
11306 netif_carrier_off(priv->net_dev);
11307
11308 ipw_stop_nic(priv);
11309
11310 ipw_led_radio_off(priv);
11311 }
11312
11313 static void ipw_bg_down(struct work_struct *work)
11314 {
11315 struct ipw_priv *priv =
11316 container_of(work, struct ipw_priv, down);
11317 mutex_lock(&priv->mutex);
11318 ipw_down(priv);
11319 mutex_unlock(&priv->mutex);
11320 }
11321
11322 static int ipw_wdev_init(struct net_device *dev)
11323 {
11324 int i, rc = 0;
11325 struct ipw_priv *priv = libipw_priv(dev);
11326 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
11327 struct wireless_dev *wdev = &priv->ieee->wdev;
11328
11329 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
11330
11331
11332 if (geo->bg_channels) {
11333 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
11334
11335 bg_band->band = NL80211_BAND_2GHZ;
11336 bg_band->n_channels = geo->bg_channels;
11337 bg_band->channels = kcalloc(geo->bg_channels,
11338 sizeof(struct ieee80211_channel),
11339 GFP_KERNEL);
11340 if (!bg_band->channels) {
11341 rc = -ENOMEM;
11342 goto out;
11343 }
11344
11345 for (i = 0; i < geo->bg_channels; i++) {
11346 bg_band->channels[i].band = NL80211_BAND_2GHZ;
11347 bg_band->channels[i].center_freq = geo->bg[i].freq;
11348 bg_band->channels[i].hw_value = geo->bg[i].channel;
11349 bg_band->channels[i].max_power = geo->bg[i].max_power;
11350 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11351 bg_band->channels[i].flags |=
11352 IEEE80211_CHAN_NO_IR;
11353 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
11354 bg_band->channels[i].flags |=
11355 IEEE80211_CHAN_NO_IR;
11356 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
11357 bg_band->channels[i].flags |=
11358 IEEE80211_CHAN_RADAR;
11359
11360
11361
11362 }
11363
11364 bg_band->bitrates = ipw2200_bg_rates;
11365 bg_band->n_bitrates = ipw2200_num_bg_rates;
11366
11367 wdev->wiphy->bands[NL80211_BAND_2GHZ] = bg_band;
11368 }
11369
11370
11371 if (geo->a_channels) {
11372 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
11373
11374 a_band->band = NL80211_BAND_5GHZ;
11375 a_band->n_channels = geo->a_channels;
11376 a_band->channels = kcalloc(geo->a_channels,
11377 sizeof(struct ieee80211_channel),
11378 GFP_KERNEL);
11379 if (!a_band->channels) {
11380 rc = -ENOMEM;
11381 goto out;
11382 }
11383
11384 for (i = 0; i < geo->a_channels; i++) {
11385 a_band->channels[i].band = NL80211_BAND_5GHZ;
11386 a_band->channels[i].center_freq = geo->a[i].freq;
11387 a_band->channels[i].hw_value = geo->a[i].channel;
11388 a_band->channels[i].max_power = geo->a[i].max_power;
11389 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11390 a_band->channels[i].flags |=
11391 IEEE80211_CHAN_NO_IR;
11392 if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
11393 a_band->channels[i].flags |=
11394 IEEE80211_CHAN_NO_IR;
11395 if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
11396 a_band->channels[i].flags |=
11397 IEEE80211_CHAN_RADAR;
11398
11399
11400
11401 }
11402
11403 a_band->bitrates = ipw2200_a_rates;
11404 a_band->n_bitrates = ipw2200_num_a_rates;
11405
11406 wdev->wiphy->bands[NL80211_BAND_5GHZ] = a_band;
11407 }
11408
11409 wdev->wiphy->cipher_suites = ipw_cipher_suites;
11410 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(ipw_cipher_suites);
11411
11412 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
11413
11414
11415 if (wiphy_register(wdev->wiphy))
11416 rc = -EIO;
11417 out:
11418 return rc;
11419 }
11420
11421
11422 static const struct pci_device_id card_ids[] = {
11423 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11424 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11425 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11426 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11427 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11428 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11429 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11430 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11431 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11432 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11433 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11434 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11435 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11436 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11437 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11438 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11439 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
11440 {PCI_VDEVICE(INTEL, 0x104f), 0},
11441 {PCI_VDEVICE(INTEL, 0x4220), 0},
11442 {PCI_VDEVICE(INTEL, 0x4221), 0},
11443 {PCI_VDEVICE(INTEL, 0x4223), 0},
11444 {PCI_VDEVICE(INTEL, 0x4224), 0},
11445
11446
11447 {0,}
11448 };
11449
11450 MODULE_DEVICE_TABLE(pci, card_ids);
11451
11452 static struct attribute *ipw_sysfs_entries[] = {
11453 &dev_attr_rf_kill.attr,
11454 &dev_attr_direct_dword.attr,
11455 &dev_attr_indirect_byte.attr,
11456 &dev_attr_indirect_dword.attr,
11457 &dev_attr_mem_gpio_reg.attr,
11458 &dev_attr_command_event_reg.attr,
11459 &dev_attr_nic_type.attr,
11460 &dev_attr_status.attr,
11461 &dev_attr_cfg.attr,
11462 &dev_attr_error.attr,
11463 &dev_attr_event_log.attr,
11464 &dev_attr_cmd_log.attr,
11465 &dev_attr_eeprom_delay.attr,
11466 &dev_attr_ucode_version.attr,
11467 &dev_attr_rtc.attr,
11468 &dev_attr_scan_age.attr,
11469 &dev_attr_led.attr,
11470 &dev_attr_speed_scan.attr,
11471 &dev_attr_net_stats.attr,
11472 &dev_attr_channels.attr,
11473 #ifdef CONFIG_IPW2200_PROMISCUOUS
11474 &dev_attr_rtap_iface.attr,
11475 &dev_attr_rtap_filter.attr,
11476 #endif
11477 NULL
11478 };
11479
11480 static const struct attribute_group ipw_attribute_group = {
11481 .name = NULL,
11482 .attrs = ipw_sysfs_entries,
11483 };
11484
11485 #ifdef CONFIG_IPW2200_PROMISCUOUS
11486 static int ipw_prom_open(struct net_device *dev)
11487 {
11488 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
11489 struct ipw_priv *priv = prom_priv->priv;
11490
11491 IPW_DEBUG_INFO("prom dev->open\n");
11492 netif_carrier_off(dev);
11493
11494 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11495 priv->sys_config.accept_all_data_frames = 1;
11496 priv->sys_config.accept_non_directed_frames = 1;
11497 priv->sys_config.accept_all_mgmt_bcpr = 1;
11498 priv->sys_config.accept_all_mgmt_frames = 1;
11499
11500 ipw_send_system_config(priv);
11501 }
11502
11503 return 0;
11504 }
11505
11506 static int ipw_prom_stop(struct net_device *dev)
11507 {
11508 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
11509 struct ipw_priv *priv = prom_priv->priv;
11510
11511 IPW_DEBUG_INFO("prom dev->stop\n");
11512
11513 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11514 priv->sys_config.accept_all_data_frames = 0;
11515 priv->sys_config.accept_non_directed_frames = 0;
11516 priv->sys_config.accept_all_mgmt_bcpr = 0;
11517 priv->sys_config.accept_all_mgmt_frames = 0;
11518
11519 ipw_send_system_config(priv);
11520 }
11521
11522 return 0;
11523 }
11524
11525 static netdev_tx_t ipw_prom_hard_start_xmit(struct sk_buff *skb,
11526 struct net_device *dev)
11527 {
11528 IPW_DEBUG_INFO("prom dev->xmit\n");
11529 dev_kfree_skb(skb);
11530 return NETDEV_TX_OK;
11531 }
11532
11533 static const struct net_device_ops ipw_prom_netdev_ops = {
11534 .ndo_open = ipw_prom_open,
11535 .ndo_stop = ipw_prom_stop,
11536 .ndo_start_xmit = ipw_prom_hard_start_xmit,
11537 .ndo_set_mac_address = eth_mac_addr,
11538 .ndo_validate_addr = eth_validate_addr,
11539 };
11540
11541 static int ipw_prom_alloc(struct ipw_priv *priv)
11542 {
11543 int rc = 0;
11544
11545 if (priv->prom_net_dev)
11546 return -EPERM;
11547
11548 priv->prom_net_dev = alloc_libipw(sizeof(struct ipw_prom_priv), 1);
11549 if (priv->prom_net_dev == NULL)
11550 return -ENOMEM;
11551
11552 priv->prom_priv = libipw_priv(priv->prom_net_dev);
11553 priv->prom_priv->ieee = netdev_priv(priv->prom_net_dev);
11554 priv->prom_priv->priv = priv;
11555
11556 strcpy(priv->prom_net_dev->name, "rtap%d");
11557 memcpy(priv->prom_net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
11558
11559 priv->prom_net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
11560 priv->prom_net_dev->netdev_ops = &ipw_prom_netdev_ops;
11561
11562 priv->prom_net_dev->min_mtu = 68;
11563 priv->prom_net_dev->max_mtu = LIBIPW_DATA_LEN;
11564
11565 priv->prom_priv->ieee->iw_mode = IW_MODE_MONITOR;
11566 SET_NETDEV_DEV(priv->prom_net_dev, &priv->pci_dev->dev);
11567
11568 rc = register_netdev(priv->prom_net_dev);
11569 if (rc) {
11570 free_libipw(priv->prom_net_dev, 1);
11571 priv->prom_net_dev = NULL;
11572 return rc;
11573 }
11574
11575 return 0;
11576 }
11577
11578 static void ipw_prom_free(struct ipw_priv *priv)
11579 {
11580 if (!priv->prom_net_dev)
11581 return;
11582
11583 unregister_netdev(priv->prom_net_dev);
11584 free_libipw(priv->prom_net_dev, 1);
11585
11586 priv->prom_net_dev = NULL;
11587 }
11588
11589 #endif
11590
11591 static const struct net_device_ops ipw_netdev_ops = {
11592 .ndo_open = ipw_net_open,
11593 .ndo_stop = ipw_net_stop,
11594 .ndo_set_rx_mode = ipw_net_set_multicast_list,
11595 .ndo_set_mac_address = ipw_net_set_mac_address,
11596 .ndo_start_xmit = libipw_xmit,
11597 .ndo_validate_addr = eth_validate_addr,
11598 };
11599
11600 static int ipw_pci_probe(struct pci_dev *pdev,
11601 const struct pci_device_id *ent)
11602 {
11603 int err = 0;
11604 struct net_device *net_dev;
11605 void __iomem *base;
11606 u32 length, val;
11607 struct ipw_priv *priv;
11608 int i;
11609
11610 net_dev = alloc_libipw(sizeof(struct ipw_priv), 0);
11611 if (net_dev == NULL) {
11612 err = -ENOMEM;
11613 goto out;
11614 }
11615
11616 priv = libipw_priv(net_dev);
11617 priv->ieee = netdev_priv(net_dev);
11618
11619 priv->net_dev = net_dev;
11620 priv->pci_dev = pdev;
11621 ipw_debug_level = debug;
11622 spin_lock_init(&priv->irq_lock);
11623 spin_lock_init(&priv->lock);
11624 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11625 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
11626
11627 mutex_init(&priv->mutex);
11628 if (pci_enable_device(pdev)) {
11629 err = -ENODEV;
11630 goto out_free_libipw;
11631 }
11632
11633 pci_set_master(pdev);
11634
11635 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
11636 if (!err)
11637 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
11638 if (err) {
11639 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11640 goto out_pci_disable_device;
11641 }
11642
11643 pci_set_drvdata(pdev, priv);
11644
11645 err = pci_request_regions(pdev, DRV_NAME);
11646 if (err)
11647 goto out_pci_disable_device;
11648
11649
11650
11651 pci_read_config_dword(pdev, 0x40, &val);
11652 if ((val & 0x0000ff00) != 0)
11653 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11654
11655 length = pci_resource_len(pdev, 0);
11656 priv->hw_len = length;
11657
11658 base = pci_ioremap_bar(pdev, 0);
11659 if (!base) {
11660 err = -ENODEV;
11661 goto out_pci_release_regions;
11662 }
11663
11664 priv->hw_base = base;
11665 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11666 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11667
11668 err = ipw_setup_deferred_work(priv);
11669 if (err) {
11670 IPW_ERROR("Unable to setup deferred work\n");
11671 goto out_iounmap;
11672 }
11673
11674 ipw_sw_reset(priv, 1);
11675
11676 err = request_irq(pdev->irq, ipw_isr, IRQF_SHARED, DRV_NAME, priv);
11677 if (err) {
11678 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11679 goto out_iounmap;
11680 }
11681
11682 SET_NETDEV_DEV(net_dev, &pdev->dev);
11683
11684 mutex_lock(&priv->mutex);
11685
11686 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11687 priv->ieee->set_security = shim__set_security;
11688 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11689
11690 #ifdef CONFIG_IPW2200_QOS
11691 priv->ieee->is_qos_active = ipw_is_qos_active;
11692 priv->ieee->handle_probe_response = ipw_handle_beacon;
11693 priv->ieee->handle_beacon = ipw_handle_probe_response;
11694 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11695 #endif
11696
11697 priv->ieee->perfect_rssi = -20;
11698 priv->ieee->worst_rssi = -85;
11699
11700 net_dev->netdev_ops = &ipw_netdev_ops;
11701 priv->wireless_data.spy_data = &priv->ieee->spy_data;
11702 net_dev->wireless_data = &priv->wireless_data;
11703 net_dev->wireless_handlers = &ipw_wx_handler_def;
11704 net_dev->ethtool_ops = &ipw_ethtool_ops;
11705
11706 net_dev->min_mtu = 68;
11707 net_dev->max_mtu = LIBIPW_DATA_LEN;
11708
11709 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11710 if (err) {
11711 IPW_ERROR("failed to create sysfs device attributes\n");
11712 mutex_unlock(&priv->mutex);
11713 goto out_release_irq;
11714 }
11715
11716 if (ipw_up(priv)) {
11717 mutex_unlock(&priv->mutex);
11718 err = -EIO;
11719 goto out_remove_sysfs;
11720 }
11721
11722 mutex_unlock(&priv->mutex);
11723
11724 err = ipw_wdev_init(net_dev);
11725 if (err) {
11726 IPW_ERROR("failed to register wireless device\n");
11727 goto out_remove_sysfs;
11728 }
11729
11730 err = register_netdev(net_dev);
11731 if (err) {
11732 IPW_ERROR("failed to register network device\n");
11733 goto out_unregister_wiphy;
11734 }
11735
11736 #ifdef CONFIG_IPW2200_PROMISCUOUS
11737 if (rtap_iface) {
11738 err = ipw_prom_alloc(priv);
11739 if (err) {
11740 IPW_ERROR("Failed to register promiscuous network "
11741 "device (error %d).\n", err);
11742 unregister_netdev(priv->net_dev);
11743 goto out_unregister_wiphy;
11744 }
11745 }
11746 #endif
11747
11748 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
11749 "channels, %d 802.11a channels)\n",
11750 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11751 priv->ieee->geo.a_channels);
11752
11753 return 0;
11754
11755 out_unregister_wiphy:
11756 wiphy_unregister(priv->ieee->wdev.wiphy);
11757 kfree(priv->ieee->a_band.channels);
11758 kfree(priv->ieee->bg_band.channels);
11759 out_remove_sysfs:
11760 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11761 out_release_irq:
11762 free_irq(pdev->irq, priv);
11763 out_iounmap:
11764 iounmap(priv->hw_base);
11765 out_pci_release_regions:
11766 pci_release_regions(pdev);
11767 out_pci_disable_device:
11768 pci_disable_device(pdev);
11769 out_free_libipw:
11770 free_libipw(priv->net_dev, 0);
11771 out:
11772 return err;
11773 }
11774
11775 static void ipw_pci_remove(struct pci_dev *pdev)
11776 {
11777 struct ipw_priv *priv = pci_get_drvdata(pdev);
11778 struct list_head *p, *q;
11779 int i;
11780
11781 if (!priv)
11782 return;
11783
11784 mutex_lock(&priv->mutex);
11785
11786 priv->status |= STATUS_EXIT_PENDING;
11787 ipw_down(priv);
11788 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11789
11790 mutex_unlock(&priv->mutex);
11791
11792 unregister_netdev(priv->net_dev);
11793
11794 if (priv->rxq) {
11795 ipw_rx_queue_free(priv, priv->rxq);
11796 priv->rxq = NULL;
11797 }
11798 ipw_tx_queue_free(priv);
11799
11800 if (priv->cmdlog) {
11801 kfree(priv->cmdlog);
11802 priv->cmdlog = NULL;
11803 }
11804
11805
11806 cancel_delayed_work_sync(&priv->adhoc_check);
11807 cancel_work_sync(&priv->associate);
11808 cancel_work_sync(&priv->disassociate);
11809 cancel_work_sync(&priv->system_config);
11810 cancel_work_sync(&priv->rx_replenish);
11811 cancel_work_sync(&priv->adapter_restart);
11812 cancel_delayed_work_sync(&priv->rf_kill);
11813 cancel_work_sync(&priv->up);
11814 cancel_work_sync(&priv->down);
11815 cancel_delayed_work_sync(&priv->request_scan);
11816 cancel_delayed_work_sync(&priv->request_direct_scan);
11817 cancel_delayed_work_sync(&priv->request_passive_scan);
11818 cancel_delayed_work_sync(&priv->scan_event);
11819 cancel_delayed_work_sync(&priv->gather_stats);
11820 cancel_work_sync(&priv->abort_scan);
11821 cancel_work_sync(&priv->roam);
11822 cancel_delayed_work_sync(&priv->scan_check);
11823 cancel_work_sync(&priv->link_up);
11824 cancel_work_sync(&priv->link_down);
11825 cancel_delayed_work_sync(&priv->led_link_on);
11826 cancel_delayed_work_sync(&priv->led_link_off);
11827 cancel_delayed_work_sync(&priv->led_act_off);
11828 cancel_work_sync(&priv->merge_networks);
11829
11830
11831 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11832 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11833 list_del(p);
11834 kfree(list_entry(p, struct ipw_ibss_seq, list));
11835 }
11836 }
11837
11838 kfree(priv->error);
11839 priv->error = NULL;
11840
11841 #ifdef CONFIG_IPW2200_PROMISCUOUS
11842 ipw_prom_free(priv);
11843 #endif
11844
11845 free_irq(pdev->irq, priv);
11846 iounmap(priv->hw_base);
11847 pci_release_regions(pdev);
11848 pci_disable_device(pdev);
11849
11850 wiphy_unregister(priv->ieee->wdev.wiphy);
11851 kfree(priv->ieee->a_band.channels);
11852 kfree(priv->ieee->bg_band.channels);
11853 free_libipw(priv->net_dev, 0);
11854 free_firmware();
11855 }
11856
11857 #ifdef CONFIG_PM
11858 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11859 {
11860 struct ipw_priv *priv = pci_get_drvdata(pdev);
11861 struct net_device *dev = priv->net_dev;
11862
11863 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11864
11865
11866 ipw_down(priv);
11867
11868
11869 netif_device_detach(dev);
11870
11871 pci_save_state(pdev);
11872 pci_disable_device(pdev);
11873 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11874
11875 priv->suspend_at = ktime_get_boottime_seconds();
11876
11877 return 0;
11878 }
11879
11880 static int ipw_pci_resume(struct pci_dev *pdev)
11881 {
11882 struct ipw_priv *priv = pci_get_drvdata(pdev);
11883 struct net_device *dev = priv->net_dev;
11884 int err;
11885 u32 val;
11886
11887 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11888
11889 pci_set_power_state(pdev, PCI_D0);
11890 err = pci_enable_device(pdev);
11891 if (err) {
11892 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
11893 dev->name);
11894 return err;
11895 }
11896 pci_restore_state(pdev);
11897
11898
11899
11900
11901
11902
11903
11904 pci_read_config_dword(pdev, 0x40, &val);
11905 if ((val & 0x0000ff00) != 0)
11906 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11907
11908
11909
11910 netif_device_attach(dev);
11911
11912 priv->suspend_time = ktime_get_boottime_seconds() - priv->suspend_at;
11913
11914
11915 schedule_work(&priv->up);
11916
11917 return 0;
11918 }
11919 #endif
11920
11921 static void ipw_pci_shutdown(struct pci_dev *pdev)
11922 {
11923 struct ipw_priv *priv = pci_get_drvdata(pdev);
11924
11925
11926 ipw_down(priv);
11927
11928 pci_disable_device(pdev);
11929 }
11930
11931
11932 static struct pci_driver ipw_driver = {
11933 .name = DRV_NAME,
11934 .id_table = card_ids,
11935 .probe = ipw_pci_probe,
11936 .remove = ipw_pci_remove,
11937 #ifdef CONFIG_PM
11938 .suspend = ipw_pci_suspend,
11939 .resume = ipw_pci_resume,
11940 #endif
11941 .shutdown = ipw_pci_shutdown,
11942 };
11943
11944 static int __init ipw_init(void)
11945 {
11946 int ret;
11947
11948 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11949 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11950
11951 ret = pci_register_driver(&ipw_driver);
11952 if (ret) {
11953 IPW_ERROR("Unable to initialize PCI module\n");
11954 return ret;
11955 }
11956
11957 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11958 if (ret) {
11959 IPW_ERROR("Unable to create driver sysfs file\n");
11960 pci_unregister_driver(&ipw_driver);
11961 return ret;
11962 }
11963
11964 return ret;
11965 }
11966
11967 static void __exit ipw_exit(void)
11968 {
11969 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11970 pci_unregister_driver(&ipw_driver);
11971 }
11972
11973 module_param(disable, int, 0444);
11974 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11975
11976 module_param(associate, int, 0444);
11977 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
11978
11979 module_param(auto_create, int, 0444);
11980 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11981
11982 module_param_named(led, led_support, int, 0444);
11983 MODULE_PARM_DESC(led, "enable led control on some systems (default 1 on)");
11984
11985 module_param(debug, int, 0444);
11986 MODULE_PARM_DESC(debug, "debug output mask");
11987
11988 module_param_named(channel, default_channel, int, 0444);
11989 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11990
11991 #ifdef CONFIG_IPW2200_PROMISCUOUS
11992 module_param(rtap_iface, int, 0444);
11993 MODULE_PARM_DESC(rtap_iface, "create the rtap interface (1 - create, default 0)");
11994 #endif
11995
11996 #ifdef CONFIG_IPW2200_QOS
11997 module_param(qos_enable, int, 0444);
11998 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalities");
11999
12000 module_param(qos_burst_enable, int, 0444);
12001 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
12002
12003 module_param(qos_no_ack_mask, int, 0444);
12004 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
12005
12006 module_param(burst_duration_CCK, int, 0444);
12007 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
12008
12009 module_param(burst_duration_OFDM, int, 0444);
12010 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
12011 #endif
12012
12013 #ifdef CONFIG_IPW2200_MONITOR
12014 module_param_named(mode, network_mode, int, 0444);
12015 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
12016 #else
12017 module_param_named(mode, network_mode, int, 0444);
12018 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
12019 #endif
12020
12021 module_param(bt_coexist, int, 0444);
12022 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
12023
12024 module_param(hwcrypto, int, 0444);
12025 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
12026
12027 module_param(cmdlog, int, 0444);
12028 MODULE_PARM_DESC(cmdlog,
12029 "allocate a ring buffer for logging firmware commands");
12030
12031 module_param(roaming, int, 0444);
12032 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
12033
12034 module_param(antenna, int, 0444);
12035 MODULE_PARM_DESC(antenna, "select antenna 1=Main, 3=Aux, default 0 [both], 2=slow_diversity (choose the one with lower background noise)");
12036
12037 module_exit(ipw_exit);
12038 module_init(ipw_init);