aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlegacy/common.c
diff options
context:
space:
mode:
authorStanislaw Gruszka <sgruszka@redhat.com>2011-11-15 07:40:15 -0500
committerStanislaw Gruszka <sgruszka@redhat.com>2011-11-15 07:40:15 -0500
commit0cdc21363cc27989fe9aa1cde614ef4c0429d62f (patch)
treebf3b098f2976b566490e842915450ca7efd9a07b /drivers/net/wireless/iwlegacy/common.c
parent4ed47911a2e0f9a425d22253433452ffa59d533e (diff)
iwlegacy: merge common .c files
Merge iwl-{tx,rx,sta,scan,power,eeprom,led,hcmd}.c into common.c . Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>
Diffstat (limited to 'drivers/net/wireless/iwlegacy/common.c')
-rw-r--r--drivers/net/wireless/iwlegacy/common.c3146
1 files changed, 3146 insertions, 0 deletions
diff --git a/drivers/net/wireless/iwlegacy/common.c b/drivers/net/wireless/iwlegacy/common.c
index 856a321ed1ea..7062574df365 100644
--- a/drivers/net/wireless/iwlegacy/common.c
+++ b/drivers/net/wireless/iwlegacy/common.c
@@ -31,6 +31,13 @@
31#include <linux/etherdevice.h> 31#include <linux/etherdevice.h>
32#include <linux/sched.h> 32#include <linux/sched.h>
33#include <linux/slab.h> 33#include <linux/slab.h>
34#include <linux/types.h>
35#include <linux/lockdep.h>
36#include <linux/init.h>
37#include <linux/pci.h>
38#include <linux/dma-mapping.h>
39#include <linux/delay.h>
40#include <linux/skbuff.h>
34#include <net/mac80211.h> 41#include <net/mac80211.h>
35 42
36#include "iwl-eeprom.h" 43#include "iwl-eeprom.h"
@@ -42,6 +49,3145 @@
42#include "iwl-sta.h" 49#include "iwl-sta.h"
43#include "iwl-helpers.h" 50#include "iwl-helpers.h"
44 51
52const char *il_get_cmd_string(u8 cmd)
53{
54 switch (cmd) {
55 IL_CMD(N_ALIVE);
56 IL_CMD(N_ERROR);
57 IL_CMD(C_RXON);
58 IL_CMD(C_RXON_ASSOC);
59 IL_CMD(C_QOS_PARAM);
60 IL_CMD(C_RXON_TIMING);
61 IL_CMD(C_ADD_STA);
62 IL_CMD(C_REM_STA);
63 IL_CMD(C_WEPKEY);
64 IL_CMD(N_3945_RX);
65 IL_CMD(C_TX);
66 IL_CMD(C_RATE_SCALE);
67 IL_CMD(C_LEDS);
68 IL_CMD(C_TX_LINK_QUALITY_CMD);
69 IL_CMD(C_CHANNEL_SWITCH);
70 IL_CMD(N_CHANNEL_SWITCH);
71 IL_CMD(C_SPECTRUM_MEASUREMENT);
72 IL_CMD(N_SPECTRUM_MEASUREMENT);
73 IL_CMD(C_POWER_TBL);
74 IL_CMD(N_PM_SLEEP);
75 IL_CMD(N_PM_DEBUG_STATS);
76 IL_CMD(C_SCAN);
77 IL_CMD(C_SCAN_ABORT);
78 IL_CMD(N_SCAN_START);
79 IL_CMD(N_SCAN_RESULTS);
80 IL_CMD(N_SCAN_COMPLETE);
81 IL_CMD(N_BEACON);
82 IL_CMD(C_TX_BEACON);
83 IL_CMD(C_TX_PWR_TBL);
84 IL_CMD(C_BT_CONFIG);
85 IL_CMD(C_STATS);
86 IL_CMD(N_STATS);
87 IL_CMD(N_CARD_STATE);
88 IL_CMD(N_MISSED_BEACONS);
89 IL_CMD(C_CT_KILL_CONFIG);
90 IL_CMD(C_SENSITIVITY);
91 IL_CMD(C_PHY_CALIBRATION);
92 IL_CMD(N_RX_PHY);
93 IL_CMD(N_RX_MPDU);
94 IL_CMD(N_RX);
95 IL_CMD(N_COMPRESSED_BA);
96 default:
97 return "UNKNOWN";
98
99 }
100}
101EXPORT_SYMBOL(il_get_cmd_string);
102
103#define HOST_COMPLETE_TIMEOUT (HZ / 2)
104
105static void il_generic_cmd_callback(struct il_priv *il,
106 struct il_device_cmd *cmd,
107 struct il_rx_pkt *pkt)
108{
109 if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
110 IL_ERR("Bad return from %s (0x%08X)\n",
111 il_get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
112 return;
113 }
114
115#ifdef CONFIG_IWLEGACY_DEBUG
116 switch (cmd->hdr.cmd) {
117 case C_TX_LINK_QUALITY_CMD:
118 case C_SENSITIVITY:
119 D_HC_DUMP("back from %s (0x%08X)\n",
120 il_get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
121 break;
122 default:
123 D_HC("back from %s (0x%08X)\n",
124 il_get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
125 }
126#endif
127}
128
129static int
130il_send_cmd_async(struct il_priv *il, struct il_host_cmd *cmd)
131{
132 int ret;
133
134 BUG_ON(!(cmd->flags & CMD_ASYNC));
135
136 /* An asynchronous command can not expect an SKB to be set. */
137 BUG_ON(cmd->flags & CMD_WANT_SKB);
138
139 /* Assign a generic callback if one is not provided */
140 if (!cmd->callback)
141 cmd->callback = il_generic_cmd_callback;
142
143 if (test_bit(S_EXIT_PENDING, &il->status))
144 return -EBUSY;
145
146 ret = il_enqueue_hcmd(il, cmd);
147 if (ret < 0) {
148 IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
149 il_get_cmd_string(cmd->id), ret);
150 return ret;
151 }
152 return 0;
153}
154
155int il_send_cmd_sync(struct il_priv *il, struct il_host_cmd *cmd)
156{
157 int cmd_idx;
158 int ret;
159
160 lockdep_assert_held(&il->mutex);
161
162 BUG_ON(cmd->flags & CMD_ASYNC);
163
164 /* A synchronous command can not have a callback set. */
165 BUG_ON(cmd->callback);
166
167 D_INFO("Attempting to send sync command %s\n",
168 il_get_cmd_string(cmd->id));
169
170 set_bit(S_HCMD_ACTIVE, &il->status);
171 D_INFO("Setting HCMD_ACTIVE for command %s\n",
172 il_get_cmd_string(cmd->id));
173
174 cmd_idx = il_enqueue_hcmd(il, cmd);
175 if (cmd_idx < 0) {
176 ret = cmd_idx;
177 IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
178 il_get_cmd_string(cmd->id), ret);
179 goto out;
180 }
181
182 ret = wait_event_timeout(il->wait_command_queue,
183 !test_bit(S_HCMD_ACTIVE, &il->status),
184 HOST_COMPLETE_TIMEOUT);
185 if (!ret) {
186 if (test_bit(S_HCMD_ACTIVE, &il->status)) {
187 IL_ERR(
188 "Error sending %s: time out after %dms.\n",
189 il_get_cmd_string(cmd->id),
190 jiffies_to_msecs(HOST_COMPLETE_TIMEOUT));
191
192 clear_bit(S_HCMD_ACTIVE, &il->status);
193 D_INFO(
194 "Clearing HCMD_ACTIVE for command %s\n",
195 il_get_cmd_string(cmd->id));
196 ret = -ETIMEDOUT;
197 goto cancel;
198 }
199 }
200
201 if (test_bit(S_RF_KILL_HW, &il->status)) {
202 IL_ERR("Command %s aborted: RF KILL Switch\n",
203 il_get_cmd_string(cmd->id));
204 ret = -ECANCELED;
205 goto fail;
206 }
207 if (test_bit(S_FW_ERROR, &il->status)) {
208 IL_ERR("Command %s failed: FW Error\n",
209 il_get_cmd_string(cmd->id));
210 ret = -EIO;
211 goto fail;
212 }
213 if ((cmd->flags & CMD_WANT_SKB) && !cmd->reply_page) {
214 IL_ERR("Error: Response NULL in '%s'\n",
215 il_get_cmd_string(cmd->id));
216 ret = -EIO;
217 goto cancel;
218 }
219
220 ret = 0;
221 goto out;
222
223cancel:
224 if (cmd->flags & CMD_WANT_SKB) {
225 /*
226 * Cancel the CMD_WANT_SKB flag for the cmd in the
227 * TX cmd queue. Otherwise in case the cmd comes
228 * in later, it will possibly set an invalid
229 * address (cmd->meta.source).
230 */
231 il->txq[il->cmd_queue].meta[cmd_idx].flags &=
232 ~CMD_WANT_SKB;
233 }
234fail:
235 if (cmd->reply_page) {
236 il_free_pages(il, cmd->reply_page);
237 cmd->reply_page = 0;
238 }
239out:
240 return ret;
241}
242EXPORT_SYMBOL(il_send_cmd_sync);
243
244int il_send_cmd(struct il_priv *il, struct il_host_cmd *cmd)
245{
246 if (cmd->flags & CMD_ASYNC)
247 return il_send_cmd_async(il, cmd);
248
249 return il_send_cmd_sync(il, cmd);
250}
251EXPORT_SYMBOL(il_send_cmd);
252
253int
254il_send_cmd_pdu(struct il_priv *il, u8 id, u16 len, const void *data)
255{
256 struct il_host_cmd cmd = {
257 .id = id,
258 .len = len,
259 .data = data,
260 };
261
262 return il_send_cmd_sync(il, &cmd);
263}
264EXPORT_SYMBOL(il_send_cmd_pdu);
265
266int il_send_cmd_pdu_async(struct il_priv *il,
267 u8 id, u16 len, const void *data,
268 void (*callback)(struct il_priv *il,
269 struct il_device_cmd *cmd,
270 struct il_rx_pkt *pkt))
271{
272 struct il_host_cmd cmd = {
273 .id = id,
274 .len = len,
275 .data = data,
276 };
277
278 cmd.flags |= CMD_ASYNC;
279 cmd.callback = callback;
280
281 return il_send_cmd_async(il, &cmd);
282}
283EXPORT_SYMBOL(il_send_cmd_pdu_async);
284
285/* default: IL_LED_BLINK(0) using blinking idx table */
286static int led_mode;
287module_param(led_mode, int, S_IRUGO);
288MODULE_PARM_DESC(led_mode, "0=system default, "
289 "1=On(RF On)/Off(RF Off), 2=blinking");
290
291/* Throughput OFF time(ms) ON time (ms)
292 * >300 25 25
293 * >200 to 300 40 40
294 * >100 to 200 55 55
295 * >70 to 100 65 65
296 * >50 to 70 75 75
297 * >20 to 50 85 85
298 * >10 to 20 95 95
299 * >5 to 10 110 110
300 * >1 to 5 130 130
301 * >0 to 1 167 167
302 * <=0 SOLID ON
303 */
304static const struct ieee80211_tpt_blink il_blink[] = {
305 { .throughput = 0, .blink_time = 334 },
306 { .throughput = 1 * 1024 - 1, .blink_time = 260 },
307 { .throughput = 5 * 1024 - 1, .blink_time = 220 },
308 { .throughput = 10 * 1024 - 1, .blink_time = 190 },
309 { .throughput = 20 * 1024 - 1, .blink_time = 170 },
310 { .throughput = 50 * 1024 - 1, .blink_time = 150 },
311 { .throughput = 70 * 1024 - 1, .blink_time = 130 },
312 { .throughput = 100 * 1024 - 1, .blink_time = 110 },
313 { .throughput = 200 * 1024 - 1, .blink_time = 80 },
314 { .throughput = 300 * 1024 - 1, .blink_time = 50 },
315};
316
317/*
318 * Adjust led blink rate to compensate on a MAC Clock difference on every HW
319 * Led blink rate analysis showed an average deviation of 0% on 3945,
320 * 5% on 4965 HW.
321 * Need to compensate on the led on/off time per HW according to the deviation
322 * to achieve the desired led frequency
323 * The calculation is: (100-averageDeviation)/100 * blinkTime
324 * For code efficiency the calculation will be:
325 * compensation = (100 - averageDeviation) * 64 / 100
326 * NewBlinkTime = (compensation * BlinkTime) / 64
327 */
328static inline u8 il_blink_compensation(struct il_priv *il,
329 u8 time, u16 compensation)
330{
331 if (!compensation) {
332 IL_ERR("undefined blink compensation: "
333 "use pre-defined blinking time\n");
334 return time;
335 }
336
337 return (u8)((time * compensation) >> 6);
338}
339
340/* Set led pattern command */
341static int il_led_cmd(struct il_priv *il,
342 unsigned long on,
343 unsigned long off)
344{
345 struct il_led_cmd led_cmd = {
346 .id = IL_LED_LINK,
347 .interval = IL_DEF_LED_INTRVL
348 };
349 int ret;
350
351 if (!test_bit(S_READY, &il->status))
352 return -EBUSY;
353
354 if (il->blink_on == on && il->blink_off == off)
355 return 0;
356
357 if (off == 0) {
358 /* led is SOLID_ON */
359 on = IL_LED_SOLID;
360 }
361
362 D_LED("Led blink time compensation=%u\n",
363 il->cfg->base_params->led_compensation);
364 led_cmd.on = il_blink_compensation(il, on,
365 il->cfg->base_params->led_compensation);
366 led_cmd.off = il_blink_compensation(il, off,
367 il->cfg->base_params->led_compensation);
368
369 ret = il->cfg->ops->led->cmd(il, &led_cmd);
370 if (!ret) {
371 il->blink_on = on;
372 il->blink_off = off;
373 }
374 return ret;
375}
376
377static void il_led_brightness_set(struct led_classdev *led_cdev,
378 enum led_brightness brightness)
379{
380 struct il_priv *il = container_of(led_cdev, struct il_priv, led);
381 unsigned long on = 0;
382
383 if (brightness > 0)
384 on = IL_LED_SOLID;
385
386 il_led_cmd(il, on, 0);
387}
388
389static int il_led_blink_set(struct led_classdev *led_cdev,
390 unsigned long *delay_on,
391 unsigned long *delay_off)
392{
393 struct il_priv *il = container_of(led_cdev, struct il_priv, led);
394
395 return il_led_cmd(il, *delay_on, *delay_off);
396}
397
398void il_leds_init(struct il_priv *il)
399{
400 int mode = led_mode;
401 int ret;
402
403 if (mode == IL_LED_DEFAULT)
404 mode = il->cfg->led_mode;
405
406 il->led.name = kasprintf(GFP_KERNEL, "%s-led",
407 wiphy_name(il->hw->wiphy));
408 il->led.brightness_set = il_led_brightness_set;
409 il->led.blink_set = il_led_blink_set;
410 il->led.max_brightness = 1;
411
412 switch (mode) {
413 case IL_LED_DEFAULT:
414 WARN_ON(1);
415 break;
416 case IL_LED_BLINK:
417 il->led.default_trigger =
418 ieee80211_create_tpt_led_trigger(il->hw,
419 IEEE80211_TPT_LEDTRIG_FL_CONNECTED,
420 il_blink, ARRAY_SIZE(il_blink));
421 break;
422 case IL_LED_RF_STATE:
423 il->led.default_trigger =
424 ieee80211_get_radio_led_name(il->hw);
425 break;
426 }
427
428 ret = led_classdev_register(&il->pci_dev->dev, &il->led);
429 if (ret) {
430 kfree(il->led.name);
431 return;
432 }
433
434 il->led_registered = true;
435}
436EXPORT_SYMBOL(il_leds_init);
437
438void il_leds_exit(struct il_priv *il)
439{
440 if (!il->led_registered)
441 return;
442
443 led_classdev_unregister(&il->led);
444 kfree(il->led.name);
445}
446EXPORT_SYMBOL(il_leds_exit);
447
448/************************** EEPROM BANDS ****************************
449 *
450 * The il_eeprom_band definitions below provide the mapping from the
451 * EEPROM contents to the specific channel number supported for each
452 * band.
453 *
454 * For example, il_priv->eeprom.band_3_channels[4] from the band_3
455 * definition below maps to physical channel 42 in the 5.2GHz spectrum.
456 * The specific geography and calibration information for that channel
457 * is contained in the eeprom map itself.
458 *
459 * During init, we copy the eeprom information and channel map
460 * information into il->channel_info_24/52 and il->channel_map_24/52
461 *
462 * channel_map_24/52 provides the idx in the channel_info array for a
463 * given channel. We have to have two separate maps as there is channel
464 * overlap with the 2.4GHz and 5.2GHz spectrum as seen in band_1 and
465 * band_2
466 *
467 * A value of 0xff stored in the channel_map indicates that the channel
468 * is not supported by the hardware at all.
469 *
470 * A value of 0xfe in the channel_map indicates that the channel is not
471 * valid for Tx with the current hardware. This means that
472 * while the system can tune and receive on a given channel, it may not
473 * be able to associate or transmit any frames on that
474 * channel. There is no corresponding channel information for that
475 * entry.
476 *
477 *********************************************************************/
478
479/* 2.4 GHz */
480const u8 il_eeprom_band_1[14] = {
481 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
482};
483
484/* 5.2 GHz bands */
485static const u8 il_eeprom_band_2[] = { /* 4915-5080MHz */
486 183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
487};
488
489static const u8 il_eeprom_band_3[] = { /* 5170-5320MHz */
490 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
491};
492
493static const u8 il_eeprom_band_4[] = { /* 5500-5700MHz */
494 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
495};
496
497static const u8 il_eeprom_band_5[] = { /* 5725-5825MHz */
498 145, 149, 153, 157, 161, 165
499};
500
501static const u8 il_eeprom_band_6[] = { /* 2.4 ht40 channel */
502 1, 2, 3, 4, 5, 6, 7
503};
504
505static const u8 il_eeprom_band_7[] = { /* 5.2 ht40 channel */
506 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157
507};
508
509/******************************************************************************
510 *
511 * EEPROM related functions
512 *
513******************************************************************************/
514
515static int il_eeprom_verify_signature(struct il_priv *il)
516{
517 u32 gp = _il_rd(il, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
518 int ret = 0;
519
520 D_EEPROM("EEPROM signature=0x%08x\n", gp);
521 switch (gp) {
522 case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K:
523 case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K:
524 break;
525 default:
526 IL_ERR("bad EEPROM signature,"
527 "EEPROM_GP=0x%08x\n", gp);
528 ret = -ENOENT;
529 break;
530 }
531 return ret;
532}
533
534const u8
535*il_eeprom_query_addr(const struct il_priv *il, size_t offset)
536{
537 BUG_ON(offset >= il->cfg->base_params->eeprom_size);
538 return &il->eeprom[offset];
539}
540EXPORT_SYMBOL(il_eeprom_query_addr);
541
542u16 il_eeprom_query16(const struct il_priv *il, size_t offset)
543{
544 if (!il->eeprom)
545 return 0;
546 return (u16)il->eeprom[offset] | ((u16)il->eeprom[offset + 1] << 8);
547}
548EXPORT_SYMBOL(il_eeprom_query16);
549
550/**
551 * il_eeprom_init - read EEPROM contents
552 *
553 * Load the EEPROM contents from adapter into il->eeprom
554 *
555 * NOTE: This routine uses the non-debug IO access functions.
556 */
557int il_eeprom_init(struct il_priv *il)
558{
559 __le16 *e;
560 u32 gp = _il_rd(il, CSR_EEPROM_GP);
561 int sz;
562 int ret;
563 u16 addr;
564
565 /* allocate eeprom */
566 sz = il->cfg->base_params->eeprom_size;
567 D_EEPROM("NVM size = %d\n", sz);
568 il->eeprom = kzalloc(sz, GFP_KERNEL);
569 if (!il->eeprom) {
570 ret = -ENOMEM;
571 goto alloc_err;
572 }
573 e = (__le16 *)il->eeprom;
574
575 il->cfg->ops->lib->apm_ops.init(il);
576
577 ret = il_eeprom_verify_signature(il);
578 if (ret < 0) {
579 IL_ERR("EEPROM not found, EEPROM_GP=0x%08x\n", gp);
580 ret = -ENOENT;
581 goto err;
582 }
583
584 /* Make sure driver (instead of uCode) is allowed to read EEPROM */
585 ret = il->cfg->ops->lib->eeprom_ops.acquire_semaphore(il);
586 if (ret < 0) {
587 IL_ERR("Failed to acquire EEPROM semaphore.\n");
588 ret = -ENOENT;
589 goto err;
590 }
591
592 /* eeprom is an array of 16bit values */
593 for (addr = 0; addr < sz; addr += sizeof(u16)) {
594 u32 r;
595
596 _il_wr(il, CSR_EEPROM_REG,
597 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
598
599 ret = _il_poll_bit(il, CSR_EEPROM_REG,
600 CSR_EEPROM_REG_READ_VALID_MSK,
601 CSR_EEPROM_REG_READ_VALID_MSK,
602 IL_EEPROM_ACCESS_TIMEOUT);
603 if (ret < 0) {
604 IL_ERR("Time out reading EEPROM[%d]\n",
605 addr);
606 goto done;
607 }
608 r = _il_rd(il, CSR_EEPROM_REG);
609 e[addr / 2] = cpu_to_le16(r >> 16);
610 }
611
612 D_EEPROM("NVM Type: %s, version: 0x%x\n",
613 "EEPROM",
614 il_eeprom_query16(il, EEPROM_VERSION));
615
616 ret = 0;
617done:
618 il->cfg->ops->lib->eeprom_ops.release_semaphore(il);
619
620err:
621 if (ret)
622 il_eeprom_free(il);
623 /* Reset chip to save power until we load uCode during "up". */
624 il_apm_stop(il);
625alloc_err:
626 return ret;
627}
628EXPORT_SYMBOL(il_eeprom_init);
629
630void il_eeprom_free(struct il_priv *il)
631{
632 kfree(il->eeprom);
633 il->eeprom = NULL;
634}
635EXPORT_SYMBOL(il_eeprom_free);
636
637static void il_init_band_reference(const struct il_priv *il,
638 int eep_band, int *eeprom_ch_count,
639 const struct il_eeprom_channel **eeprom_ch_info,
640 const u8 **eeprom_ch_idx)
641{
642 u32 offset = il->cfg->ops->lib->
643 eeprom_ops.regulatory_bands[eep_band - 1];
644 switch (eep_band) {
645 case 1: /* 2.4GHz band */
646 *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_1);
647 *eeprom_ch_info = (struct il_eeprom_channel *)
648 il_eeprom_query_addr(il, offset);
649 *eeprom_ch_idx = il_eeprom_band_1;
650 break;
651 case 2: /* 4.9GHz band */
652 *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_2);
653 *eeprom_ch_info = (struct il_eeprom_channel *)
654 il_eeprom_query_addr(il, offset);
655 *eeprom_ch_idx = il_eeprom_band_2;
656 break;
657 case 3: /* 5.2GHz band */
658 *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_3);
659 *eeprom_ch_info = (struct il_eeprom_channel *)
660 il_eeprom_query_addr(il, offset);
661 *eeprom_ch_idx = il_eeprom_band_3;
662 break;
663 case 4: /* 5.5GHz band */
664 *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_4);
665 *eeprom_ch_info = (struct il_eeprom_channel *)
666 il_eeprom_query_addr(il, offset);
667 *eeprom_ch_idx = il_eeprom_band_4;
668 break;
669 case 5: /* 5.7GHz band */
670 *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_5);
671 *eeprom_ch_info = (struct il_eeprom_channel *)
672 il_eeprom_query_addr(il, offset);
673 *eeprom_ch_idx = il_eeprom_band_5;
674 break;
675 case 6: /* 2.4GHz ht40 channels */
676 *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_6);
677 *eeprom_ch_info = (struct il_eeprom_channel *)
678 il_eeprom_query_addr(il, offset);
679 *eeprom_ch_idx = il_eeprom_band_6;
680 break;
681 case 7: /* 5 GHz ht40 channels */
682 *eeprom_ch_count = ARRAY_SIZE(il_eeprom_band_7);
683 *eeprom_ch_info = (struct il_eeprom_channel *)
684 il_eeprom_query_addr(il, offset);
685 *eeprom_ch_idx = il_eeprom_band_7;
686 break;
687 default:
688 BUG();
689 }
690}
691
692#define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
693 ? # x " " : "")
694/**
695 * il_mod_ht40_chan_info - Copy ht40 channel info into driver's il.
696 *
697 * Does not set up a command, or touch hardware.
698 */
699static int il_mod_ht40_chan_info(struct il_priv *il,
700 enum ieee80211_band band, u16 channel,
701 const struct il_eeprom_channel *eeprom_ch,
702 u8 clear_ht40_extension_channel)
703{
704 struct il_channel_info *ch_info;
705
706 ch_info = (struct il_channel_info *)
707 il_get_channel_info(il, band, channel);
708
709 if (!il_is_channel_valid(ch_info))
710 return -1;
711
712 D_EEPROM("HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
713 " Ad-Hoc %ssupported\n",
714 ch_info->channel,
715 il_is_channel_a_band(ch_info) ?
716 "5.2" : "2.4",
717 CHECK_AND_PRINT(IBSS),
718 CHECK_AND_PRINT(ACTIVE),
719 CHECK_AND_PRINT(RADAR),
720 CHECK_AND_PRINT(WIDE),
721 CHECK_AND_PRINT(DFS),
722 eeprom_ch->flags,
723 eeprom_ch->max_power_avg,
724 ((eeprom_ch->flags & EEPROM_CHANNEL_IBSS)
725 && !(eeprom_ch->flags & EEPROM_CHANNEL_RADAR)) ?
726 "" : "not ");
727
728 ch_info->ht40_eeprom = *eeprom_ch;
729 ch_info->ht40_max_power_avg = eeprom_ch->max_power_avg;
730 ch_info->ht40_flags = eeprom_ch->flags;
731 if (eeprom_ch->flags & EEPROM_CHANNEL_VALID)
732 ch_info->ht40_extension_channel &=
733 ~clear_ht40_extension_channel;
734
735 return 0;
736}
737
738#define CHECK_AND_PRINT_I(x) ((eeprom_ch_info[ch].flags & EEPROM_CHANNEL_##x) \
739 ? # x " " : "")
740
741/**
742 * il_init_channel_map - Set up driver's info for all possible channels
743 */
744int il_init_channel_map(struct il_priv *il)
745{
746 int eeprom_ch_count = 0;
747 const u8 *eeprom_ch_idx = NULL;
748 const struct il_eeprom_channel *eeprom_ch_info = NULL;
749 int band, ch;
750 struct il_channel_info *ch_info;
751
752 if (il->channel_count) {
753 D_EEPROM("Channel map already initialized.\n");
754 return 0;
755 }
756
757 D_EEPROM("Initializing regulatory info from EEPROM\n");
758
759 il->channel_count =
760 ARRAY_SIZE(il_eeprom_band_1) +
761 ARRAY_SIZE(il_eeprom_band_2) +
762 ARRAY_SIZE(il_eeprom_band_3) +
763 ARRAY_SIZE(il_eeprom_band_4) +
764 ARRAY_SIZE(il_eeprom_band_5);
765
766 D_EEPROM("Parsing data for %d channels.\n",
767 il->channel_count);
768
769 il->channel_info = kzalloc(sizeof(struct il_channel_info) *
770 il->channel_count, GFP_KERNEL);
771 if (!il->channel_info) {
772 IL_ERR("Could not allocate channel_info\n");
773 il->channel_count = 0;
774 return -ENOMEM;
775 }
776
777 ch_info = il->channel_info;
778
779 /* Loop through the 5 EEPROM bands adding them in order to the
780 * channel map we maintain (that contains additional information than
781 * what just in the EEPROM) */
782 for (band = 1; band <= 5; band++) {
783
784 il_init_band_reference(il, band, &eeprom_ch_count,
785 &eeprom_ch_info, &eeprom_ch_idx);
786
787 /* Loop through each band adding each of the channels */
788 for (ch = 0; ch < eeprom_ch_count; ch++) {
789 ch_info->channel = eeprom_ch_idx[ch];
790 ch_info->band = (band == 1) ? IEEE80211_BAND_2GHZ :
791 IEEE80211_BAND_5GHZ;
792
793 /* permanently store EEPROM's channel regulatory flags
794 * and max power in channel info database. */
795 ch_info->eeprom = eeprom_ch_info[ch];
796
797 /* Copy the run-time flags so they are there even on
798 * invalid channels */
799 ch_info->flags = eeprom_ch_info[ch].flags;
800 /* First write that ht40 is not enabled, and then enable
801 * one by one */
802 ch_info->ht40_extension_channel =
803 IEEE80211_CHAN_NO_HT40;
804
805 if (!(il_is_channel_valid(ch_info))) {
806 D_EEPROM(
807 "Ch. %d Flags %x [%sGHz] - "
808 "No traffic\n",
809 ch_info->channel,
810 ch_info->flags,
811 il_is_channel_a_band(ch_info) ?
812 "5.2" : "2.4");
813 ch_info++;
814 continue;
815 }
816
817 /* Initialize regulatory-based run-time data */
818 ch_info->max_power_avg = ch_info->curr_txpow =
819 eeprom_ch_info[ch].max_power_avg;
820 ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
821 ch_info->min_power = 0;
822
823 D_EEPROM("Ch. %d [%sGHz] "
824 "%s%s%s%s%s%s(0x%02x %ddBm):"
825 " Ad-Hoc %ssupported\n",
826 ch_info->channel,
827 il_is_channel_a_band(ch_info) ?
828 "5.2" : "2.4",
829 CHECK_AND_PRINT_I(VALID),
830 CHECK_AND_PRINT_I(IBSS),
831 CHECK_AND_PRINT_I(ACTIVE),
832 CHECK_AND_PRINT_I(RADAR),
833 CHECK_AND_PRINT_I(WIDE),
834 CHECK_AND_PRINT_I(DFS),
835 eeprom_ch_info[ch].flags,
836 eeprom_ch_info[ch].max_power_avg,
837 ((eeprom_ch_info[ch].
838 flags & EEPROM_CHANNEL_IBSS)
839 && !(eeprom_ch_info[ch].
840 flags & EEPROM_CHANNEL_RADAR))
841 ? "" : "not ");
842
843 ch_info++;
844 }
845 }
846
847 /* Check if we do have HT40 channels */
848 if (il->cfg->ops->lib->eeprom_ops.regulatory_bands[5] ==
849 EEPROM_REGULATORY_BAND_NO_HT40 &&
850 il->cfg->ops->lib->eeprom_ops.regulatory_bands[6] ==
851 EEPROM_REGULATORY_BAND_NO_HT40)
852 return 0;
853
854 /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
855 for (band = 6; band <= 7; band++) {
856 enum ieee80211_band ieeeband;
857
858 il_init_band_reference(il, band, &eeprom_ch_count,
859 &eeprom_ch_info, &eeprom_ch_idx);
860
861 /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
862 ieeeband =
863 (band == 6) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
864
865 /* Loop through each band adding each of the channels */
866 for (ch = 0; ch < eeprom_ch_count; ch++) {
867 /* Set up driver's info for lower half */
868 il_mod_ht40_chan_info(il, ieeeband,
869 eeprom_ch_idx[ch],
870 &eeprom_ch_info[ch],
871 IEEE80211_CHAN_NO_HT40PLUS);
872
873 /* Set up driver's info for upper half */
874 il_mod_ht40_chan_info(il, ieeeband,
875 eeprom_ch_idx[ch] + 4,
876 &eeprom_ch_info[ch],
877 IEEE80211_CHAN_NO_HT40MINUS);
878 }
879 }
880
881 return 0;
882}
883EXPORT_SYMBOL(il_init_channel_map);
884
885/*
886 * il_free_channel_map - undo allocations in il_init_channel_map
887 */
888void il_free_channel_map(struct il_priv *il)
889{
890 kfree(il->channel_info);
891 il->channel_count = 0;
892}
893EXPORT_SYMBOL(il_free_channel_map);
894
895/**
896 * il_get_channel_info - Find driver's ilate channel info
897 *
898 * Based on band and channel number.
899 */
900const struct
901il_channel_info *il_get_channel_info(const struct il_priv *il,
902 enum ieee80211_band band, u16 channel)
903{
904 int i;
905
906 switch (band) {
907 case IEEE80211_BAND_5GHZ:
908 for (i = 14; i < il->channel_count; i++) {
909 if (il->channel_info[i].channel == channel)
910 return &il->channel_info[i];
911 }
912 break;
913 case IEEE80211_BAND_2GHZ:
914 if (channel >= 1 && channel <= 14)
915 return &il->channel_info[channel - 1];
916 break;
917 default:
918 BUG();
919 }
920
921 return NULL;
922}
923EXPORT_SYMBOL(il_get_channel_info);
924
925/*
926 * Setting power level allows the card to go to sleep when not busy.
927 *
928 * We calculate a sleep command based on the required latency, which
929 * we get from mac80211. In order to handle thermal throttling, we can
930 * also use pre-defined power levels.
931 */
932
933/*
934 * This defines the old power levels. They are still used by default
935 * (level 1) and for thermal throttle (levels 3 through 5)
936 */
937
938struct il_power_vec_entry {
939 struct il_powertable_cmd cmd;
940 u8 no_dtim; /* number of skip dtim */
941};
942
943static void il_power_sleep_cam_cmd(struct il_priv *il,
944 struct il_powertable_cmd *cmd)
945{
946 memset(cmd, 0, sizeof(*cmd));
947
948 if (il->power_data.pci_pm)
949 cmd->flags |= IL_POWER_PCI_PM_MSK;
950
951 D_POWER("Sleep command for CAM\n");
952}
953
954static int
955il_set_power(struct il_priv *il, struct il_powertable_cmd *cmd)
956{
957 D_POWER("Sending power/sleep command\n");
958 D_POWER("Flags value = 0x%08X\n", cmd->flags);
959 D_POWER("Tx timeout = %u\n",
960 le32_to_cpu(cmd->tx_data_timeout));
961 D_POWER("Rx timeout = %u\n",
962 le32_to_cpu(cmd->rx_data_timeout));
963 D_POWER(
964 "Sleep interval vector = { %d , %d , %d , %d , %d }\n",
965 le32_to_cpu(cmd->sleep_interval[0]),
966 le32_to_cpu(cmd->sleep_interval[1]),
967 le32_to_cpu(cmd->sleep_interval[2]),
968 le32_to_cpu(cmd->sleep_interval[3]),
969 le32_to_cpu(cmd->sleep_interval[4]));
970
971 return il_send_cmd_pdu(il, C_POWER_TBL,
972 sizeof(struct il_powertable_cmd), cmd);
973}
974
975int
976il_power_set_mode(struct il_priv *il, struct il_powertable_cmd *cmd,
977 bool force)
978{
979 int ret;
980 bool update_chains;
981
982 lockdep_assert_held(&il->mutex);
983
984 /* Don't update the RX chain when chain noise calibration is running */
985 update_chains = il->chain_noise_data.state == IL_CHAIN_NOISE_DONE ||
986 il->chain_noise_data.state == IL_CHAIN_NOISE_ALIVE;
987
988 if (!memcmp(&il->power_data.sleep_cmd, cmd, sizeof(*cmd)) && !force)
989 return 0;
990
991 if (!il_is_ready_rf(il))
992 return -EIO;
993
994 /* scan complete use sleep_power_next, need to be updated */
995 memcpy(&il->power_data.sleep_cmd_next, cmd, sizeof(*cmd));
996 if (test_bit(S_SCANNING, &il->status) && !force) {
997 D_INFO("Defer power set mode while scanning\n");
998 return 0;
999 }
1000
1001 if (cmd->flags & IL_POWER_DRIVER_ALLOW_SLEEP_MSK)
1002 set_bit(S_POWER_PMI, &il->status);
1003
1004 ret = il_set_power(il, cmd);
1005 if (!ret) {
1006 if (!(cmd->flags & IL_POWER_DRIVER_ALLOW_SLEEP_MSK))
1007 clear_bit(S_POWER_PMI, &il->status);
1008
1009 if (il->cfg->ops->lib->update_chain_flags && update_chains)
1010 il->cfg->ops->lib->update_chain_flags(il);
1011 else if (il->cfg->ops->lib->update_chain_flags)
1012 D_POWER(
1013 "Cannot update the power, chain noise "
1014 "calibration running: %d\n",
1015 il->chain_noise_data.state);
1016
1017 memcpy(&il->power_data.sleep_cmd, cmd, sizeof(*cmd));
1018 } else
1019 IL_ERR("set power fail, ret = %d", ret);
1020
1021 return ret;
1022}
1023
1024int il_power_update_mode(struct il_priv *il, bool force)
1025{
1026 struct il_powertable_cmd cmd;
1027
1028 il_power_sleep_cam_cmd(il, &cmd);
1029 return il_power_set_mode(il, &cmd, force);
1030}
1031EXPORT_SYMBOL(il_power_update_mode);
1032
1033/* initialize to default */
1034void il_power_initialize(struct il_priv *il)
1035{
1036 u16 lctl = il_pcie_link_ctl(il);
1037
1038 il->power_data.pci_pm = !(lctl & PCI_CFG_LINK_CTRL_VAL_L0S_EN);
1039
1040 il->power_data.debug_sleep_level_override = -1;
1041
1042 memset(&il->power_data.sleep_cmd, 0,
1043 sizeof(il->power_data.sleep_cmd));
1044}
1045EXPORT_SYMBOL(il_power_initialize);
1046
1047/* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
1048 * sending probe req. This should be set long enough to hear probe responses
1049 * from more than one AP. */
1050#define IL_ACTIVE_DWELL_TIME_24 (30) /* all times in msec */
1051#define IL_ACTIVE_DWELL_TIME_52 (20)
1052
1053#define IL_ACTIVE_DWELL_FACTOR_24GHZ (3)
1054#define IL_ACTIVE_DWELL_FACTOR_52GHZ (2)
1055
1056/* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
1057 * Must be set longer than active dwell time.
1058 * For the most reliable scan, set > AP beacon interval (typically 100msec). */
1059#define IL_PASSIVE_DWELL_TIME_24 (20) /* all times in msec */
1060#define IL_PASSIVE_DWELL_TIME_52 (10)
1061#define IL_PASSIVE_DWELL_BASE (100)
1062#define IL_CHANNEL_TUNE_TIME 5
1063
1064static int il_send_scan_abort(struct il_priv *il)
1065{
1066 int ret;
1067 struct il_rx_pkt *pkt;
1068 struct il_host_cmd cmd = {
1069 .id = C_SCAN_ABORT,
1070 .flags = CMD_WANT_SKB,
1071 };
1072
1073 /* Exit instantly with error when device is not ready
1074 * to receive scan abort command or it does not perform
1075 * hardware scan currently */
1076 if (!test_bit(S_READY, &il->status) ||
1077 !test_bit(S_GEO_CONFIGURED, &il->status) ||
1078 !test_bit(S_SCAN_HW, &il->status) ||
1079 test_bit(S_FW_ERROR, &il->status) ||
1080 test_bit(S_EXIT_PENDING, &il->status))
1081 return -EIO;
1082
1083 ret = il_send_cmd_sync(il, &cmd);
1084 if (ret)
1085 return ret;
1086
1087 pkt = (struct il_rx_pkt *)cmd.reply_page;
1088 if (pkt->u.status != CAN_ABORT_STATUS) {
1089 /* The scan abort will return 1 for success or
1090 * 2 for "failure". A failure condition can be
1091 * due to simply not being in an active scan which
1092 * can occur if we send the scan abort before we
1093 * the microcode has notified us that a scan is
1094 * completed. */
1095 D_SCAN("SCAN_ABORT ret %d.\n", pkt->u.status);
1096 ret = -EIO;
1097 }
1098
1099 il_free_pages(il, cmd.reply_page);
1100 return ret;
1101}
1102
1103static void il_complete_scan(struct il_priv *il, bool aborted)
1104{
1105 /* check if scan was requested from mac80211 */
1106 if (il->scan_request) {
1107 D_SCAN("Complete scan in mac80211\n");
1108 ieee80211_scan_completed(il->hw, aborted);
1109 }
1110
1111 il->scan_vif = NULL;
1112 il->scan_request = NULL;
1113}
1114
1115void il_force_scan_end(struct il_priv *il)
1116{
1117 lockdep_assert_held(&il->mutex);
1118
1119 if (!test_bit(S_SCANNING, &il->status)) {
1120 D_SCAN("Forcing scan end while not scanning\n");
1121 return;
1122 }
1123
1124 D_SCAN("Forcing scan end\n");
1125 clear_bit(S_SCANNING, &il->status);
1126 clear_bit(S_SCAN_HW, &il->status);
1127 clear_bit(S_SCAN_ABORTING, &il->status);
1128 il_complete_scan(il, true);
1129}
1130
1131static void il_do_scan_abort(struct il_priv *il)
1132{
1133 int ret;
1134
1135 lockdep_assert_held(&il->mutex);
1136
1137 if (!test_bit(S_SCANNING, &il->status)) {
1138 D_SCAN("Not performing scan to abort\n");
1139 return;
1140 }
1141
1142 if (test_and_set_bit(S_SCAN_ABORTING, &il->status)) {
1143 D_SCAN("Scan abort in progress\n");
1144 return;
1145 }
1146
1147 ret = il_send_scan_abort(il);
1148 if (ret) {
1149 D_SCAN("Send scan abort failed %d\n", ret);
1150 il_force_scan_end(il);
1151 } else
1152 D_SCAN("Successfully send scan abort\n");
1153}
1154
1155/**
1156 * il_scan_cancel - Cancel any currently executing HW scan
1157 */
1158int il_scan_cancel(struct il_priv *il)
1159{
1160 D_SCAN("Queuing abort scan\n");
1161 queue_work(il->workqueue, &il->abort_scan);
1162 return 0;
1163}
1164EXPORT_SYMBOL(il_scan_cancel);
1165
1166/**
1167 * il_scan_cancel_timeout - Cancel any currently executing HW scan
1168 * @ms: amount of time to wait (in milliseconds) for scan to abort
1169 *
1170 */
1171int il_scan_cancel_timeout(struct il_priv *il, unsigned long ms)
1172{
1173 unsigned long timeout = jiffies + msecs_to_jiffies(ms);
1174
1175 lockdep_assert_held(&il->mutex);
1176
1177 D_SCAN("Scan cancel timeout\n");
1178
1179 il_do_scan_abort(il);
1180
1181 while (time_before_eq(jiffies, timeout)) {
1182 if (!test_bit(S_SCAN_HW, &il->status))
1183 break;
1184 msleep(20);
1185 }
1186
1187 return test_bit(S_SCAN_HW, &il->status);
1188}
1189EXPORT_SYMBOL(il_scan_cancel_timeout);
1190
1191/* Service response to C_SCAN (0x80) */
1192static void il_hdl_scan(struct il_priv *il,
1193 struct il_rx_buf *rxb)
1194{
1195#ifdef CONFIG_IWLEGACY_DEBUG
1196 struct il_rx_pkt *pkt = rxb_addr(rxb);
1197 struct il_scanreq_notification *notif =
1198 (struct il_scanreq_notification *)pkt->u.raw;
1199
1200 D_SCAN("Scan request status = 0x%x\n", notif->status);
1201#endif
1202}
1203
1204/* Service N_SCAN_START (0x82) */
1205static void il_hdl_scan_start(struct il_priv *il,
1206 struct il_rx_buf *rxb)
1207{
1208 struct il_rx_pkt *pkt = rxb_addr(rxb);
1209 struct il_scanstart_notification *notif =
1210 (struct il_scanstart_notification *)pkt->u.raw;
1211 il->scan_start_tsf = le32_to_cpu(notif->tsf_low);
1212 D_SCAN("Scan start: "
1213 "%d [802.11%s] "
1214 "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
1215 notif->channel,
1216 notif->band ? "bg" : "a",
1217 le32_to_cpu(notif->tsf_high),
1218 le32_to_cpu(notif->tsf_low),
1219 notif->status, notif->beacon_timer);
1220}
1221
1222/* Service N_SCAN_RESULTS (0x83) */
1223static void il_hdl_scan_results(struct il_priv *il,
1224 struct il_rx_buf *rxb)
1225{
1226#ifdef CONFIG_IWLEGACY_DEBUG
1227 struct il_rx_pkt *pkt = rxb_addr(rxb);
1228 struct il_scanresults_notification *notif =
1229 (struct il_scanresults_notification *)pkt->u.raw;
1230
1231 D_SCAN("Scan ch.res: "
1232 "%d [802.11%s] "
1233 "(TSF: 0x%08X:%08X) - %d "
1234 "elapsed=%lu usec\n",
1235 notif->channel,
1236 notif->band ? "bg" : "a",
1237 le32_to_cpu(notif->tsf_high),
1238 le32_to_cpu(notif->tsf_low),
1239 le32_to_cpu(notif->stats[0]),
1240 le32_to_cpu(notif->tsf_low) - il->scan_start_tsf);
1241#endif
1242}
1243
1244/* Service N_SCAN_COMPLETE (0x84) */
1245static void il_hdl_scan_complete(struct il_priv *il,
1246 struct il_rx_buf *rxb)
1247{
1248
1249#ifdef CONFIG_IWLEGACY_DEBUG
1250 struct il_rx_pkt *pkt = rxb_addr(rxb);
1251 struct il_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
1252#endif
1253
1254 D_SCAN(
1255 "Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
1256 scan_notif->scanned_channels,
1257 scan_notif->tsf_low,
1258 scan_notif->tsf_high, scan_notif->status);
1259
1260 /* The HW is no longer scanning */
1261 clear_bit(S_SCAN_HW, &il->status);
1262
1263 D_SCAN("Scan on %sGHz took %dms\n",
1264 (il->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
1265 jiffies_to_msecs(jiffies - il->scan_start));
1266
1267 queue_work(il->workqueue, &il->scan_completed);
1268}
1269
1270void il_setup_rx_scan_handlers(struct il_priv *il)
1271{
1272 /* scan handlers */
1273 il->handlers[C_SCAN] = il_hdl_scan;
1274 il->handlers[N_SCAN_START] =
1275 il_hdl_scan_start;
1276 il->handlers[N_SCAN_RESULTS] =
1277 il_hdl_scan_results;
1278 il->handlers[N_SCAN_COMPLETE] =
1279 il_hdl_scan_complete;
1280}
1281EXPORT_SYMBOL(il_setup_rx_scan_handlers);
1282
1283inline u16 il_get_active_dwell_time(struct il_priv *il,
1284 enum ieee80211_band band,
1285 u8 n_probes)
1286{
1287 if (band == IEEE80211_BAND_5GHZ)
1288 return IL_ACTIVE_DWELL_TIME_52 +
1289 IL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
1290 else
1291 return IL_ACTIVE_DWELL_TIME_24 +
1292 IL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
1293}
1294EXPORT_SYMBOL(il_get_active_dwell_time);
1295
1296u16 il_get_passive_dwell_time(struct il_priv *il,
1297 enum ieee80211_band band,
1298 struct ieee80211_vif *vif)
1299{
1300 struct il_rxon_context *ctx = &il->ctx;
1301 u16 value;
1302
1303 u16 passive = (band == IEEE80211_BAND_2GHZ) ?
1304 IL_PASSIVE_DWELL_BASE + IL_PASSIVE_DWELL_TIME_24 :
1305 IL_PASSIVE_DWELL_BASE + IL_PASSIVE_DWELL_TIME_52;
1306
1307 if (il_is_any_associated(il)) {
1308 /*
1309 * If we're associated, we clamp the maximum passive
1310 * dwell time to be 98% of the smallest beacon interval
1311 * (minus 2 * channel tune time)
1312 */
1313 value = ctx->vif ? ctx->vif->bss_conf.beacon_int : 0;
1314 if (value > IL_PASSIVE_DWELL_BASE || !value)
1315 value = IL_PASSIVE_DWELL_BASE;
1316 value = (value * 98) / 100 - IL_CHANNEL_TUNE_TIME * 2;
1317 passive = min(value, passive);
1318 }
1319
1320 return passive;
1321}
1322EXPORT_SYMBOL(il_get_passive_dwell_time);
1323
1324void il_init_scan_params(struct il_priv *il)
1325{
1326 u8 ant_idx = fls(il->hw_params.valid_tx_ant) - 1;
1327 if (!il->scan_tx_ant[IEEE80211_BAND_5GHZ])
1328 il->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
1329 if (!il->scan_tx_ant[IEEE80211_BAND_2GHZ])
1330 il->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
1331}
1332EXPORT_SYMBOL(il_init_scan_params);
1333
1334static int il_scan_initiate(struct il_priv *il,
1335 struct ieee80211_vif *vif)
1336{
1337 int ret;
1338
1339 lockdep_assert_held(&il->mutex);
1340
1341 if (WARN_ON(!il->cfg->ops->utils->request_scan))
1342 return -EOPNOTSUPP;
1343
1344 cancel_delayed_work(&il->scan_check);
1345
1346 if (!il_is_ready_rf(il)) {
1347 IL_WARN("Request scan called when driver not ready.\n");
1348 return -EIO;
1349 }
1350
1351 if (test_bit(S_SCAN_HW, &il->status)) {
1352 D_SCAN(
1353 "Multiple concurrent scan requests in parallel.\n");
1354 return -EBUSY;
1355 }
1356
1357 if (test_bit(S_SCAN_ABORTING, &il->status)) {
1358 D_SCAN("Scan request while abort pending.\n");
1359 return -EBUSY;
1360 }
1361
1362 D_SCAN("Starting scan...\n");
1363
1364 set_bit(S_SCANNING, &il->status);
1365 il->scan_start = jiffies;
1366
1367 ret = il->cfg->ops->utils->request_scan(il, vif);
1368 if (ret) {
1369 clear_bit(S_SCANNING, &il->status);
1370 return ret;
1371 }
1372
1373 queue_delayed_work(il->workqueue, &il->scan_check,
1374 IL_SCAN_CHECK_WATCHDOG);
1375
1376 return 0;
1377}
1378
1379int il_mac_hw_scan(struct ieee80211_hw *hw,
1380 struct ieee80211_vif *vif,
1381 struct cfg80211_scan_request *req)
1382{
1383 struct il_priv *il = hw->priv;
1384 int ret;
1385
1386 D_MAC80211("enter\n");
1387
1388 if (req->n_channels == 0)
1389 return -EINVAL;
1390
1391 mutex_lock(&il->mutex);
1392
1393 if (test_bit(S_SCANNING, &il->status)) {
1394 D_SCAN("Scan already in progress.\n");
1395 ret = -EAGAIN;
1396 goto out_unlock;
1397 }
1398
1399 /* mac80211 will only ask for one band at a time */
1400 il->scan_request = req;
1401 il->scan_vif = vif;
1402 il->scan_band = req->channels[0]->band;
1403
1404 ret = il_scan_initiate(il, vif);
1405
1406 D_MAC80211("leave\n");
1407
1408out_unlock:
1409 mutex_unlock(&il->mutex);
1410
1411 return ret;
1412}
1413EXPORT_SYMBOL(il_mac_hw_scan);
1414
1415static void il_bg_scan_check(struct work_struct *data)
1416{
1417 struct il_priv *il =
1418 container_of(data, struct il_priv, scan_check.work);
1419
1420 D_SCAN("Scan check work\n");
1421
1422 /* Since we are here firmware does not finish scan and
1423 * most likely is in bad shape, so we don't bother to
1424 * send abort command, just force scan complete to mac80211 */
1425 mutex_lock(&il->mutex);
1426 il_force_scan_end(il);
1427 mutex_unlock(&il->mutex);
1428}
1429
1430/**
1431 * il_fill_probe_req - fill in all required fields and IE for probe request
1432 */
1433
1434u16
1435il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
1436 const u8 *ta, const u8 *ies, int ie_len, int left)
1437{
1438 int len = 0;
1439 u8 *pos = NULL;
1440
1441 /* Make sure there is enough space for the probe request,
1442 * two mandatory IEs and the data */
1443 left -= 24;
1444 if (left < 0)
1445 return 0;
1446
1447 frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
1448 memcpy(frame->da, il_bcast_addr, ETH_ALEN);
1449 memcpy(frame->sa, ta, ETH_ALEN);
1450 memcpy(frame->bssid, il_bcast_addr, ETH_ALEN);
1451 frame->seq_ctrl = 0;
1452
1453 len += 24;
1454
1455 /* ...next IE... */
1456 pos = &frame->u.probe_req.variable[0];
1457
1458 /* fill in our indirect SSID IE */
1459 left -= 2;
1460 if (left < 0)
1461 return 0;
1462 *pos++ = WLAN_EID_SSID;
1463 *pos++ = 0;
1464
1465 len += 2;
1466
1467 if (WARN_ON(left < ie_len))
1468 return len;
1469
1470 if (ies && ie_len) {
1471 memcpy(pos, ies, ie_len);
1472 len += ie_len;
1473 }
1474
1475 return (u16)len;
1476}
1477EXPORT_SYMBOL(il_fill_probe_req);
1478
1479static void il_bg_abort_scan(struct work_struct *work)
1480{
1481 struct il_priv *il = container_of(work, struct il_priv, abort_scan);
1482
1483 D_SCAN("Abort scan work\n");
1484
1485 /* We keep scan_check work queued in case when firmware will not
1486 * report back scan completed notification */
1487 mutex_lock(&il->mutex);
1488 il_scan_cancel_timeout(il, 200);
1489 mutex_unlock(&il->mutex);
1490}
1491
1492static void il_bg_scan_completed(struct work_struct *work)
1493{
1494 struct il_priv *il =
1495 container_of(work, struct il_priv, scan_completed);
1496 bool aborted;
1497
1498 D_SCAN("Completed scan.\n");
1499
1500 cancel_delayed_work(&il->scan_check);
1501
1502 mutex_lock(&il->mutex);
1503
1504 aborted = test_and_clear_bit(S_SCAN_ABORTING, &il->status);
1505 if (aborted)
1506 D_SCAN("Aborted scan completed.\n");
1507
1508 if (!test_and_clear_bit(S_SCANNING, &il->status)) {
1509 D_SCAN("Scan already completed.\n");
1510 goto out_settings;
1511 }
1512
1513 il_complete_scan(il, aborted);
1514
1515out_settings:
1516 /* Can we still talk to firmware ? */
1517 if (!il_is_ready_rf(il))
1518 goto out;
1519
1520 /*
1521 * We do not commit power settings while scan is pending,
1522 * do it now if the settings changed.
1523 */
1524 il_power_set_mode(il, &il->power_data.sleep_cmd_next, false);
1525 il_set_tx_power(il, il->tx_power_next, false);
1526
1527 il->cfg->ops->utils->post_scan(il);
1528
1529out:
1530 mutex_unlock(&il->mutex);
1531}
1532
1533void il_setup_scan_deferred_work(struct il_priv *il)
1534{
1535 INIT_WORK(&il->scan_completed, il_bg_scan_completed);
1536 INIT_WORK(&il->abort_scan, il_bg_abort_scan);
1537 INIT_DELAYED_WORK(&il->scan_check, il_bg_scan_check);
1538}
1539EXPORT_SYMBOL(il_setup_scan_deferred_work);
1540
1541void il_cancel_scan_deferred_work(struct il_priv *il)
1542{
1543 cancel_work_sync(&il->abort_scan);
1544 cancel_work_sync(&il->scan_completed);
1545
1546 if (cancel_delayed_work_sync(&il->scan_check)) {
1547 mutex_lock(&il->mutex);
1548 il_force_scan_end(il);
1549 mutex_unlock(&il->mutex);
1550 }
1551}
1552EXPORT_SYMBOL(il_cancel_scan_deferred_work);
1553
1554/* il->sta_lock must be held */
1555static void il_sta_ucode_activate(struct il_priv *il, u8 sta_id)
1556{
1557
1558 if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE))
1559 IL_ERR(
1560 "ACTIVATE a non DRIVER active station id %u addr %pM\n",
1561 sta_id, il->stations[sta_id].sta.sta.addr);
1562
1563 if (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) {
1564 D_ASSOC(
1565 "STA id %u addr %pM already present"
1566 " in uCode (according to driver)\n",
1567 sta_id, il->stations[sta_id].sta.sta.addr);
1568 } else {
1569 il->stations[sta_id].used |= IL_STA_UCODE_ACTIVE;
1570 D_ASSOC("Added STA id %u addr %pM to uCode\n",
1571 sta_id, il->stations[sta_id].sta.sta.addr);
1572 }
1573}
1574
1575static int il_process_add_sta_resp(struct il_priv *il,
1576 struct il_addsta_cmd *addsta,
1577 struct il_rx_pkt *pkt,
1578 bool sync)
1579{
1580 u8 sta_id = addsta->sta.sta_id;
1581 unsigned long flags;
1582 int ret = -EIO;
1583
1584 if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
1585 IL_ERR("Bad return from C_ADD_STA (0x%08X)\n",
1586 pkt->hdr.flags);
1587 return ret;
1588 }
1589
1590 D_INFO("Processing response for adding station %u\n",
1591 sta_id);
1592
1593 spin_lock_irqsave(&il->sta_lock, flags);
1594
1595 switch (pkt->u.add_sta.status) {
1596 case ADD_STA_SUCCESS_MSK:
1597 D_INFO("C_ADD_STA PASSED\n");
1598 il_sta_ucode_activate(il, sta_id);
1599 ret = 0;
1600 break;
1601 case ADD_STA_NO_ROOM_IN_TBL:
1602 IL_ERR("Adding station %d failed, no room in table.\n",
1603 sta_id);
1604 break;
1605 case ADD_STA_NO_BLOCK_ACK_RESOURCE:
1606 IL_ERR(
1607 "Adding station %d failed, no block ack resource.\n",
1608 sta_id);
1609 break;
1610 case ADD_STA_MODIFY_NON_EXIST_STA:
1611 IL_ERR("Attempting to modify non-existing station %d\n",
1612 sta_id);
1613 break;
1614 default:
1615 D_ASSOC("Received C_ADD_STA:(0x%08X)\n",
1616 pkt->u.add_sta.status);
1617 break;
1618 }
1619
1620 D_INFO("%s station id %u addr %pM\n",
1621 il->stations[sta_id].sta.mode ==
1622 STA_CONTROL_MODIFY_MSK ? "Modified" : "Added",
1623 sta_id, il->stations[sta_id].sta.sta.addr);
1624
1625 /*
1626 * XXX: The MAC address in the command buffer is often changed from
1627 * the original sent to the device. That is, the MAC address
1628 * written to the command buffer often is not the same MAC address
1629 * read from the command buffer when the command returns. This
1630 * issue has not yet been resolved and this debugging is left to
1631 * observe the problem.
1632 */
1633 D_INFO("%s station according to cmd buffer %pM\n",
1634 il->stations[sta_id].sta.mode ==
1635 STA_CONTROL_MODIFY_MSK ? "Modified" : "Added",
1636 addsta->sta.addr);
1637 spin_unlock_irqrestore(&il->sta_lock, flags);
1638
1639 return ret;
1640}
1641
1642static void il_add_sta_callback(struct il_priv *il,
1643 struct il_device_cmd *cmd,
1644 struct il_rx_pkt *pkt)
1645{
1646 struct il_addsta_cmd *addsta =
1647 (struct il_addsta_cmd *)cmd->cmd.payload;
1648
1649 il_process_add_sta_resp(il, addsta, pkt, false);
1650
1651}
1652
1653int il_send_add_sta(struct il_priv *il,
1654 struct il_addsta_cmd *sta, u8 flags)
1655{
1656 struct il_rx_pkt *pkt = NULL;
1657 int ret = 0;
1658 u8 data[sizeof(*sta)];
1659 struct il_host_cmd cmd = {
1660 .id = C_ADD_STA,
1661 .flags = flags,
1662 .data = data,
1663 };
1664 u8 sta_id __maybe_unused = sta->sta.sta_id;
1665
1666 D_INFO("Adding sta %u (%pM) %ssynchronously\n",
1667 sta_id, sta->sta.addr, flags & CMD_ASYNC ? "a" : "");
1668
1669 if (flags & CMD_ASYNC)
1670 cmd.callback = il_add_sta_callback;
1671 else {
1672 cmd.flags |= CMD_WANT_SKB;
1673 might_sleep();
1674 }
1675
1676 cmd.len = il->cfg->ops->utils->build_addsta_hcmd(sta, data);
1677 ret = il_send_cmd(il, &cmd);
1678
1679 if (ret || (flags & CMD_ASYNC))
1680 return ret;
1681
1682 if (ret == 0) {
1683 pkt = (struct il_rx_pkt *)cmd.reply_page;
1684 ret = il_process_add_sta_resp(il, sta, pkt, true);
1685 }
1686 il_free_pages(il, cmd.reply_page);
1687
1688 return ret;
1689}
1690EXPORT_SYMBOL(il_send_add_sta);
1691
1692static void il_set_ht_add_station(struct il_priv *il, u8 idx,
1693 struct ieee80211_sta *sta,
1694 struct il_rxon_context *ctx)
1695{
1696 struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->ht_cap;
1697 __le32 sta_flags;
1698 u8 mimo_ps_mode;
1699
1700 if (!sta || !sta_ht_inf->ht_supported)
1701 goto done;
1702
1703 mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2;
1704 D_ASSOC("spatial multiplexing power save mode: %s\n",
1705 (mimo_ps_mode == WLAN_HT_CAP_SM_PS_STATIC) ?
1706 "static" :
1707 (mimo_ps_mode == WLAN_HT_CAP_SM_PS_DYNAMIC) ?
1708 "dynamic" : "disabled");
1709
1710 sta_flags = il->stations[idx].sta.station_flags;
1711
1712 sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK);
1713
1714 switch (mimo_ps_mode) {
1715 case WLAN_HT_CAP_SM_PS_STATIC:
1716 sta_flags |= STA_FLG_MIMO_DIS_MSK;
1717 break;
1718 case WLAN_HT_CAP_SM_PS_DYNAMIC:
1719 sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK;
1720 break;
1721 case WLAN_HT_CAP_SM_PS_DISABLED:
1722 break;
1723 default:
1724 IL_WARN("Invalid MIMO PS mode %d\n", mimo_ps_mode);
1725 break;
1726 }
1727
1728 sta_flags |= cpu_to_le32(
1729 (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);
1730
1731 sta_flags |= cpu_to_le32(
1732 (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);
1733
1734 if (il_is_ht40_tx_allowed(il, ctx, &sta->ht_cap))
1735 sta_flags |= STA_FLG_HT40_EN_MSK;
1736 else
1737 sta_flags &= ~STA_FLG_HT40_EN_MSK;
1738
1739 il->stations[idx].sta.station_flags = sta_flags;
1740 done:
1741 return;
1742}
1743
1744/**
1745 * il_prep_station - Prepare station information for addition
1746 *
1747 * should be called with sta_lock held
1748 */
1749u8 il_prep_station(struct il_priv *il, struct il_rxon_context *ctx,
1750 const u8 *addr, bool is_ap, struct ieee80211_sta *sta)
1751{
1752 struct il_station_entry *station;
1753 int i;
1754 u8 sta_id = IL_INVALID_STATION;
1755 u16 rate;
1756
1757 if (is_ap)
1758 sta_id = ctx->ap_sta_id;
1759 else if (is_broadcast_ether_addr(addr))
1760 sta_id = ctx->bcast_sta_id;
1761 else
1762 for (i = IL_STA_ID; i < il->hw_params.max_stations; i++) {
1763 if (!compare_ether_addr(il->stations[i].sta.sta.addr,
1764 addr)) {
1765 sta_id = i;
1766 break;
1767 }
1768
1769 if (!il->stations[i].used &&
1770 sta_id == IL_INVALID_STATION)
1771 sta_id = i;
1772 }
1773
1774 /*
1775 * These two conditions have the same outcome, but keep them
1776 * separate
1777 */
1778 if (unlikely(sta_id == IL_INVALID_STATION))
1779 return sta_id;
1780
1781 /*
1782 * uCode is not able to deal with multiple requests to add a
1783 * station. Keep track if one is in progress so that we do not send
1784 * another.
1785 */
1786 if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) {
1787 D_INFO(
1788 "STA %d already in process of being added.\n",
1789 sta_id);
1790 return sta_id;
1791 }
1792
1793 if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) &&
1794 (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) &&
1795 !compare_ether_addr(il->stations[sta_id].sta.sta.addr, addr)) {
1796 D_ASSOC(
1797 "STA %d (%pM) already added, not adding again.\n",
1798 sta_id, addr);
1799 return sta_id;
1800 }
1801
1802 station = &il->stations[sta_id];
1803 station->used = IL_STA_DRIVER_ACTIVE;
1804 D_ASSOC("Add STA to driver ID %d: %pM\n",
1805 sta_id, addr);
1806 il->num_stations++;
1807
1808 /* Set up the C_ADD_STA command to send to device */
1809 memset(&station->sta, 0, sizeof(struct il_addsta_cmd));
1810 memcpy(station->sta.sta.addr, addr, ETH_ALEN);
1811 station->sta.mode = 0;
1812 station->sta.sta.sta_id = sta_id;
1813 station->sta.station_flags = ctx->station_flags;
1814 station->ctxid = ctx->ctxid;
1815
1816 if (sta) {
1817 struct il_station_priv_common *sta_priv;
1818
1819 sta_priv = (void *)sta->drv_priv;
1820 sta_priv->ctx = ctx;
1821 }
1822
1823 /*
1824 * OK to call unconditionally, since local stations (IBSS BSSID
1825 * STA and broadcast STA) pass in a NULL sta, and mac80211
1826 * doesn't allow HT IBSS.
1827 */
1828 il_set_ht_add_station(il, sta_id, sta, ctx);
1829
1830 /* 3945 only */
1831 rate = (il->band == IEEE80211_BAND_5GHZ) ?
1832 RATE_6M_PLCP : RATE_1M_PLCP;
1833 /* Turn on both antennas for the station... */
1834 station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK);
1835
1836 return sta_id;
1837
1838}
1839EXPORT_SYMBOL_GPL(il_prep_station);
1840
1841#define STA_WAIT_TIMEOUT (HZ/2)
1842
1843/**
1844 * il_add_station_common -
1845 */
1846int
1847il_add_station_common(struct il_priv *il,
1848 struct il_rxon_context *ctx,
1849 const u8 *addr, bool is_ap,
1850 struct ieee80211_sta *sta, u8 *sta_id_r)
1851{
1852 unsigned long flags_spin;
1853 int ret = 0;
1854 u8 sta_id;
1855 struct il_addsta_cmd sta_cmd;
1856
1857 *sta_id_r = 0;
1858 spin_lock_irqsave(&il->sta_lock, flags_spin);
1859 sta_id = il_prep_station(il, ctx, addr, is_ap, sta);
1860 if (sta_id == IL_INVALID_STATION) {
1861 IL_ERR("Unable to prepare station %pM for addition\n",
1862 addr);
1863 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
1864 return -EINVAL;
1865 }
1866
1867 /*
1868 * uCode is not able to deal with multiple requests to add a
1869 * station. Keep track if one is in progress so that we do not send
1870 * another.
1871 */
1872 if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) {
1873 D_INFO(
1874 "STA %d already in process of being added.\n",
1875 sta_id);
1876 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
1877 return -EEXIST;
1878 }
1879
1880 if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) &&
1881 (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) {
1882 D_ASSOC(
1883 "STA %d (%pM) already added, not adding again.\n",
1884 sta_id, addr);
1885 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
1886 return -EEXIST;
1887 }
1888
1889 il->stations[sta_id].used |= IL_STA_UCODE_INPROGRESS;
1890 memcpy(&sta_cmd, &il->stations[sta_id].sta,
1891 sizeof(struct il_addsta_cmd));
1892 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
1893
1894 /* Add station to device's station table */
1895 ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC);
1896 if (ret) {
1897 spin_lock_irqsave(&il->sta_lock, flags_spin);
1898 IL_ERR("Adding station %pM failed.\n",
1899 il->stations[sta_id].sta.sta.addr);
1900 il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE;
1901 il->stations[sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
1902 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
1903 }
1904 *sta_id_r = sta_id;
1905 return ret;
1906}
1907EXPORT_SYMBOL(il_add_station_common);
1908
1909/**
1910 * il_sta_ucode_deactivate - deactivate ucode status for a station
1911 *
1912 * il->sta_lock must be held
1913 */
1914static void il_sta_ucode_deactivate(struct il_priv *il, u8 sta_id)
1915{
1916 /* Ucode must be active and driver must be non active */
1917 if ((il->stations[sta_id].used &
1918 (IL_STA_UCODE_ACTIVE | IL_STA_DRIVER_ACTIVE)) !=
1919 IL_STA_UCODE_ACTIVE)
1920 IL_ERR("removed non active STA %u\n", sta_id);
1921
1922 il->stations[sta_id].used &= ~IL_STA_UCODE_ACTIVE;
1923
1924 memset(&il->stations[sta_id], 0, sizeof(struct il_station_entry));
1925 D_ASSOC("Removed STA %u\n", sta_id);
1926}
1927
1928static int il_send_remove_station(struct il_priv *il,
1929 const u8 *addr, int sta_id,
1930 bool temporary)
1931{
1932 struct il_rx_pkt *pkt;
1933 int ret;
1934
1935 unsigned long flags_spin;
1936 struct il_rem_sta_cmd rm_sta_cmd;
1937
1938 struct il_host_cmd cmd = {
1939 .id = C_REM_STA,
1940 .len = sizeof(struct il_rem_sta_cmd),
1941 .flags = CMD_SYNC,
1942 .data = &rm_sta_cmd,
1943 };
1944
1945 memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
1946 rm_sta_cmd.num_sta = 1;
1947 memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN);
1948
1949 cmd.flags |= CMD_WANT_SKB;
1950
1951 ret = il_send_cmd(il, &cmd);
1952
1953 if (ret)
1954 return ret;
1955
1956 pkt = (struct il_rx_pkt *)cmd.reply_page;
1957 if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
1958 IL_ERR("Bad return from C_REM_STA (0x%08X)\n",
1959 pkt->hdr.flags);
1960 ret = -EIO;
1961 }
1962
1963 if (!ret) {
1964 switch (pkt->u.rem_sta.status) {
1965 case REM_STA_SUCCESS_MSK:
1966 if (!temporary) {
1967 spin_lock_irqsave(&il->sta_lock, flags_spin);
1968 il_sta_ucode_deactivate(il, sta_id);
1969 spin_unlock_irqrestore(&il->sta_lock,
1970 flags_spin);
1971 }
1972 D_ASSOC("C_REM_STA PASSED\n");
1973 break;
1974 default:
1975 ret = -EIO;
1976 IL_ERR("C_REM_STA failed\n");
1977 break;
1978 }
1979 }
1980 il_free_pages(il, cmd.reply_page);
1981
1982 return ret;
1983}
1984
1985/**
1986 * il_remove_station - Remove driver's knowledge of station.
1987 */
1988int il_remove_station(struct il_priv *il, const u8 sta_id,
1989 const u8 *addr)
1990{
1991 unsigned long flags;
1992
1993 if (!il_is_ready(il)) {
1994 D_INFO(
1995 "Unable to remove station %pM, device not ready.\n",
1996 addr);
1997 /*
1998 * It is typical for stations to be removed when we are
1999 * going down. Return success since device will be down
2000 * soon anyway
2001 */
2002 return 0;
2003 }
2004
2005 D_ASSOC("Removing STA from driver:%d %pM\n",
2006 sta_id, addr);
2007
2008 if (WARN_ON(sta_id == IL_INVALID_STATION))
2009 return -EINVAL;
2010
2011 spin_lock_irqsave(&il->sta_lock, flags);
2012
2013 if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE)) {
2014 D_INFO("Removing %pM but non DRIVER active\n",
2015 addr);
2016 goto out_err;
2017 }
2018
2019 if (!(il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) {
2020 D_INFO("Removing %pM but non UCODE active\n",
2021 addr);
2022 goto out_err;
2023 }
2024
2025 if (il->stations[sta_id].used & IL_STA_LOCAL) {
2026 kfree(il->stations[sta_id].lq);
2027 il->stations[sta_id].lq = NULL;
2028 }
2029
2030 il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE;
2031
2032 il->num_stations--;
2033
2034 BUG_ON(il->num_stations < 0);
2035
2036 spin_unlock_irqrestore(&il->sta_lock, flags);
2037
2038 return il_send_remove_station(il, addr, sta_id, false);
2039out_err:
2040 spin_unlock_irqrestore(&il->sta_lock, flags);
2041 return -EINVAL;
2042}
2043EXPORT_SYMBOL_GPL(il_remove_station);
2044
2045/**
2046 * il_clear_ucode_stations - clear ucode station table bits
2047 *
2048 * This function clears all the bits in the driver indicating
2049 * which stations are active in the ucode. Call when something
2050 * other than explicit station management would cause this in
2051 * the ucode, e.g. unassociated RXON.
2052 */
2053void il_clear_ucode_stations(struct il_priv *il,
2054 struct il_rxon_context *ctx)
2055{
2056 int i;
2057 unsigned long flags_spin;
2058 bool cleared = false;
2059
2060 D_INFO("Clearing ucode stations in driver\n");
2061
2062 spin_lock_irqsave(&il->sta_lock, flags_spin);
2063 for (i = 0; i < il->hw_params.max_stations; i++) {
2064 if (ctx && ctx->ctxid != il->stations[i].ctxid)
2065 continue;
2066
2067 if (il->stations[i].used & IL_STA_UCODE_ACTIVE) {
2068 D_INFO(
2069 "Clearing ucode active for station %d\n", i);
2070 il->stations[i].used &= ~IL_STA_UCODE_ACTIVE;
2071 cleared = true;
2072 }
2073 }
2074 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
2075
2076 if (!cleared)
2077 D_INFO(
2078 "No active stations found to be cleared\n");
2079}
2080EXPORT_SYMBOL(il_clear_ucode_stations);
2081
2082/**
2083 * il_restore_stations() - Restore driver known stations to device
2084 *
2085 * All stations considered active by driver, but not present in ucode, is
2086 * restored.
2087 *
2088 * Function sleeps.
2089 */
2090void
2091il_restore_stations(struct il_priv *il, struct il_rxon_context *ctx)
2092{
2093 struct il_addsta_cmd sta_cmd;
2094 struct il_link_quality_cmd lq;
2095 unsigned long flags_spin;
2096 int i;
2097 bool found = false;
2098 int ret;
2099 bool send_lq;
2100
2101 if (!il_is_ready(il)) {
2102 D_INFO(
2103 "Not ready yet, not restoring any stations.\n");
2104 return;
2105 }
2106
2107 D_ASSOC("Restoring all known stations ... start.\n");
2108 spin_lock_irqsave(&il->sta_lock, flags_spin);
2109 for (i = 0; i < il->hw_params.max_stations; i++) {
2110 if (ctx->ctxid != il->stations[i].ctxid)
2111 continue;
2112 if ((il->stations[i].used & IL_STA_DRIVER_ACTIVE) &&
2113 !(il->stations[i].used & IL_STA_UCODE_ACTIVE)) {
2114 D_ASSOC("Restoring sta %pM\n",
2115 il->stations[i].sta.sta.addr);
2116 il->stations[i].sta.mode = 0;
2117 il->stations[i].used |= IL_STA_UCODE_INPROGRESS;
2118 found = true;
2119 }
2120 }
2121
2122 for (i = 0; i < il->hw_params.max_stations; i++) {
2123 if ((il->stations[i].used & IL_STA_UCODE_INPROGRESS)) {
2124 memcpy(&sta_cmd, &il->stations[i].sta,
2125 sizeof(struct il_addsta_cmd));
2126 send_lq = false;
2127 if (il->stations[i].lq) {
2128 memcpy(&lq, il->stations[i].lq,
2129 sizeof(struct il_link_quality_cmd));
2130 send_lq = true;
2131 }
2132 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
2133 ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC);
2134 if (ret) {
2135 spin_lock_irqsave(&il->sta_lock, flags_spin);
2136 IL_ERR("Adding station %pM failed.\n",
2137 il->stations[i].sta.sta.addr);
2138 il->stations[i].used &=
2139 ~IL_STA_DRIVER_ACTIVE;
2140 il->stations[i].used &=
2141 ~IL_STA_UCODE_INPROGRESS;
2142 spin_unlock_irqrestore(&il->sta_lock,
2143 flags_spin);
2144 }
2145 /*
2146 * Rate scaling has already been initialized, send
2147 * current LQ command
2148 */
2149 if (send_lq)
2150 il_send_lq_cmd(il, ctx, &lq,
2151 CMD_SYNC, true);
2152 spin_lock_irqsave(&il->sta_lock, flags_spin);
2153 il->stations[i].used &= ~IL_STA_UCODE_INPROGRESS;
2154 }
2155 }
2156
2157 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
2158 if (!found)
2159 D_INFO("Restoring all known stations"
2160 " .... no stations to be restored.\n");
2161 else
2162 D_INFO("Restoring all known stations"
2163 " .... complete.\n");
2164}
2165EXPORT_SYMBOL(il_restore_stations);
2166
2167int il_get_free_ucode_key_idx(struct il_priv *il)
2168{
2169 int i;
2170
2171 for (i = 0; i < il->sta_key_max_num; i++)
2172 if (!test_and_set_bit(i, &il->ucode_key_table))
2173 return i;
2174
2175 return WEP_INVALID_OFFSET;
2176}
2177EXPORT_SYMBOL(il_get_free_ucode_key_idx);
2178
2179void il_dealloc_bcast_stations(struct il_priv *il)
2180{
2181 unsigned long flags;
2182 int i;
2183
2184 spin_lock_irqsave(&il->sta_lock, flags);
2185 for (i = 0; i < il->hw_params.max_stations; i++) {
2186 if (!(il->stations[i].used & IL_STA_BCAST))
2187 continue;
2188
2189 il->stations[i].used &= ~IL_STA_UCODE_ACTIVE;
2190 il->num_stations--;
2191 BUG_ON(il->num_stations < 0);
2192 kfree(il->stations[i].lq);
2193 il->stations[i].lq = NULL;
2194 }
2195 spin_unlock_irqrestore(&il->sta_lock, flags);
2196}
2197EXPORT_SYMBOL_GPL(il_dealloc_bcast_stations);
2198
2199#ifdef CONFIG_IWLEGACY_DEBUG
2200static void il_dump_lq_cmd(struct il_priv *il,
2201 struct il_link_quality_cmd *lq)
2202{
2203 int i;
2204 D_RATE("lq station id 0x%x\n", lq->sta_id);
2205 D_RATE("lq ant 0x%X 0x%X\n",
2206 lq->general_params.single_stream_ant_msk,
2207 lq->general_params.dual_stream_ant_msk);
2208
2209 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
2210 D_RATE("lq idx %d 0x%X\n",
2211 i, lq->rs_table[i].rate_n_flags);
2212}
2213#else
2214static inline void il_dump_lq_cmd(struct il_priv *il,
2215 struct il_link_quality_cmd *lq)
2216{
2217}
2218#endif
2219
2220/**
2221 * il_is_lq_table_valid() - Test one aspect of LQ cmd for validity
2222 *
2223 * It sometimes happens when a HT rate has been in use and we
2224 * loose connectivity with AP then mac80211 will first tell us that the
2225 * current channel is not HT anymore before removing the station. In such a
2226 * scenario the RXON flags will be updated to indicate we are not
2227 * communicating HT anymore, but the LQ command may still contain HT rates.
2228 * Test for this to prevent driver from sending LQ command between the time
2229 * RXON flags are updated and when LQ command is updated.
2230 */
2231static bool il_is_lq_table_valid(struct il_priv *il,
2232 struct il_rxon_context *ctx,
2233 struct il_link_quality_cmd *lq)
2234{
2235 int i;
2236
2237 if (ctx->ht.enabled)
2238 return true;
2239
2240 D_INFO("Channel %u is not an HT channel\n",
2241 ctx->active.channel);
2242 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
2243 if (le32_to_cpu(lq->rs_table[i].rate_n_flags) &
2244 RATE_MCS_HT_MSK) {
2245 D_INFO(
2246 "idx %d of LQ expects HT channel\n",
2247 i);
2248 return false;
2249 }
2250 }
2251 return true;
2252}
2253
2254/**
2255 * il_send_lq_cmd() - Send link quality command
2256 * @init: This command is sent as part of station initialization right
2257 * after station has been added.
2258 *
2259 * The link quality command is sent as the last step of station creation.
2260 * This is the special case in which init is set and we call a callback in
2261 * this case to clear the state indicating that station creation is in
2262 * progress.
2263 */
2264int il_send_lq_cmd(struct il_priv *il, struct il_rxon_context *ctx,
2265 struct il_link_quality_cmd *lq, u8 flags, bool init)
2266{
2267 int ret = 0;
2268 unsigned long flags_spin;
2269
2270 struct il_host_cmd cmd = {
2271 .id = C_TX_LINK_QUALITY_CMD,
2272 .len = sizeof(struct il_link_quality_cmd),
2273 .flags = flags,
2274 .data = lq,
2275 };
2276
2277 if (WARN_ON(lq->sta_id == IL_INVALID_STATION))
2278 return -EINVAL;
2279
2280
2281 spin_lock_irqsave(&il->sta_lock, flags_spin);
2282 if (!(il->stations[lq->sta_id].used & IL_STA_DRIVER_ACTIVE)) {
2283 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
2284 return -EINVAL;
2285 }
2286 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
2287
2288 il_dump_lq_cmd(il, lq);
2289 BUG_ON(init && (cmd.flags & CMD_ASYNC));
2290
2291 if (il_is_lq_table_valid(il, ctx, lq))
2292 ret = il_send_cmd(il, &cmd);
2293 else
2294 ret = -EINVAL;
2295
2296 if (cmd.flags & CMD_ASYNC)
2297 return ret;
2298
2299 if (init) {
2300 D_INFO("init LQ command complete,"
2301 " clearing sta addition status for sta %d\n",
2302 lq->sta_id);
2303 spin_lock_irqsave(&il->sta_lock, flags_spin);
2304 il->stations[lq->sta_id].used &= ~IL_STA_UCODE_INPROGRESS;
2305 spin_unlock_irqrestore(&il->sta_lock, flags_spin);
2306 }
2307 return ret;
2308}
2309EXPORT_SYMBOL(il_send_lq_cmd);
2310
2311int il_mac_sta_remove(struct ieee80211_hw *hw,
2312 struct ieee80211_vif *vif,
2313 struct ieee80211_sta *sta)
2314{
2315 struct il_priv *il = hw->priv;
2316 struct il_station_priv_common *sta_common = (void *)sta->drv_priv;
2317 int ret;
2318
2319 D_INFO("received request to remove station %pM\n",
2320 sta->addr);
2321 mutex_lock(&il->mutex);
2322 D_INFO("proceeding to remove station %pM\n",
2323 sta->addr);
2324 ret = il_remove_station(il, sta_common->sta_id, sta->addr);
2325 if (ret)
2326 IL_ERR("Error removing station %pM\n",
2327 sta->addr);
2328 mutex_unlock(&il->mutex);
2329 return ret;
2330}
2331EXPORT_SYMBOL(il_mac_sta_remove);
2332
2333/************************** RX-FUNCTIONS ****************************/
2334/*
2335 * Rx theory of operation
2336 *
2337 * Driver allocates a circular buffer of Receive Buffer Descriptors (RBDs),
2338 * each of which point to Receive Buffers to be filled by the NIC. These get
2339 * used not only for Rx frames, but for any command response or notification
2340 * from the NIC. The driver and NIC manage the Rx buffers by means
2341 * of idxes into the circular buffer.
2342 *
2343 * Rx Queue Indexes
2344 * The host/firmware share two idx registers for managing the Rx buffers.
2345 *
2346 * The READ idx maps to the first position that the firmware may be writing
2347 * to -- the driver can read up to (but not including) this position and get
2348 * good data.
2349 * The READ idx is managed by the firmware once the card is enabled.
2350 *
2351 * The WRITE idx maps to the last position the driver has read from -- the
2352 * position preceding WRITE is the last slot the firmware can place a packet.
2353 *
2354 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
2355 * WRITE = READ.
2356 *
2357 * During initialization, the host sets up the READ queue position to the first
2358 * IDX position, and WRITE to the last (READ - 1 wrapped)
2359 *
2360 * When the firmware places a packet in a buffer, it will advance the READ idx
2361 * and fire the RX interrupt. The driver can then query the READ idx and
2362 * process as many packets as possible, moving the WRITE idx forward as it
2363 * resets the Rx queue buffers with new memory.
2364 *
2365 * The management in the driver is as follows:
2366 * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free. When
2367 * iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
2368 * to replenish the iwl->rxq->rx_free.
2369 * + In il_rx_replenish (scheduled) if 'processed' != 'read' then the
2370 * iwl->rxq is replenished and the READ IDX is updated (updating the
2371 * 'processed' and 'read' driver idxes as well)
2372 * + A received packet is processed and handed to the kernel network stack,
2373 * detached from the iwl->rxq. The driver 'processed' idx is updated.
2374 * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
2375 * list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
2376 * IDX is not incremented and iwl->status(RX_STALLED) is set. If there
2377 * were enough free buffers and RX_STALLED is set it is cleared.
2378 *
2379 *
2380 * Driver sequence:
2381 *
2382 * il_rx_queue_alloc() Allocates rx_free
2383 * il_rx_replenish() Replenishes rx_free list from rx_used, and calls
2384 * il_rx_queue_restock
2385 * il_rx_queue_restock() Moves available buffers from rx_free into Rx
2386 * queue, updates firmware pointers, and updates
2387 * the WRITE idx. If insufficient rx_free buffers
2388 * are available, schedules il_rx_replenish
2389 *
2390 * -- enable interrupts --
2391 * ISR - il_rx() Detach il_rx_bufs from pool up to the
2392 * READ IDX, detaching the SKB from the pool.
2393 * Moves the packet buffer from queue to rx_used.
2394 * Calls il_rx_queue_restock to refill any empty
2395 * slots.
2396 * ...
2397 *
2398 */
2399
2400/**
2401 * il_rx_queue_space - Return number of free slots available in queue.
2402 */
2403int il_rx_queue_space(const struct il_rx_queue *q)
2404{
2405 int s = q->read - q->write;
2406 if (s <= 0)
2407 s += RX_QUEUE_SIZE;
2408 /* keep some buffer to not confuse full and empty queue */
2409 s -= 2;
2410 if (s < 0)
2411 s = 0;
2412 return s;
2413}
2414EXPORT_SYMBOL(il_rx_queue_space);
2415
2416/**
2417 * il_rx_queue_update_write_ptr - Update the write pointer for the RX queue
2418 */
2419void
2420il_rx_queue_update_write_ptr(struct il_priv *il,
2421 struct il_rx_queue *q)
2422{
2423 unsigned long flags;
2424 u32 rx_wrt_ptr_reg = il->hw_params.rx_wrt_ptr_reg;
2425 u32 reg;
2426
2427 spin_lock_irqsave(&q->lock, flags);
2428
2429 if (q->need_update == 0)
2430 goto exit_unlock;
2431
2432 /* If power-saving is in use, make sure device is awake */
2433 if (test_bit(S_POWER_PMI, &il->status)) {
2434 reg = _il_rd(il, CSR_UCODE_DRV_GP1);
2435
2436 if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
2437 D_INFO(
2438 "Rx queue requesting wakeup,"
2439 " GP1 = 0x%x\n", reg);
2440 il_set_bit(il, CSR_GP_CNTRL,
2441 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
2442 goto exit_unlock;
2443 }
2444
2445 q->write_actual = (q->write & ~0x7);
2446 il_wr(il, rx_wrt_ptr_reg,
2447 q->write_actual);
2448
2449 /* Else device is assumed to be awake */
2450 } else {
2451 /* Device expects a multiple of 8 */
2452 q->write_actual = (q->write & ~0x7);
2453 il_wr(il, rx_wrt_ptr_reg,
2454 q->write_actual);
2455 }
2456
2457 q->need_update = 0;
2458
2459 exit_unlock:
2460 spin_unlock_irqrestore(&q->lock, flags);
2461}
2462EXPORT_SYMBOL(il_rx_queue_update_write_ptr);
2463
2464int il_rx_queue_alloc(struct il_priv *il)
2465{
2466 struct il_rx_queue *rxq = &il->rxq;
2467 struct device *dev = &il->pci_dev->dev;
2468 int i;
2469
2470 spin_lock_init(&rxq->lock);
2471 INIT_LIST_HEAD(&rxq->rx_free);
2472 INIT_LIST_HEAD(&rxq->rx_used);
2473
2474 /* Alloc the circular buffer of Read Buffer Descriptors (RBDs) */
2475 rxq->bd = dma_alloc_coherent(dev, 4 * RX_QUEUE_SIZE, &rxq->bd_dma,
2476 GFP_KERNEL);
2477 if (!rxq->bd)
2478 goto err_bd;
2479
2480 rxq->rb_stts = dma_alloc_coherent(dev, sizeof(struct il_rb_status),
2481 &rxq->rb_stts_dma, GFP_KERNEL);
2482 if (!rxq->rb_stts)
2483 goto err_rb;
2484
2485 /* Fill the rx_used queue with _all_ of the Rx buffers */
2486 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
2487 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
2488
2489 /* Set us so that we have processed and used all buffers, but have
2490 * not restocked the Rx queue with fresh buffers */
2491 rxq->read = rxq->write = 0;
2492 rxq->write_actual = 0;
2493 rxq->free_count = 0;
2494 rxq->need_update = 0;
2495 return 0;
2496
2497err_rb:
2498 dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
2499 rxq->bd_dma);
2500err_bd:
2501 return -ENOMEM;
2502}
2503EXPORT_SYMBOL(il_rx_queue_alloc);
2504
2505
2506void il_hdl_spectrum_measurement(struct il_priv *il,
2507 struct il_rx_buf *rxb)
2508{
2509 struct il_rx_pkt *pkt = rxb_addr(rxb);
2510 struct il_spectrum_notification *report = &(pkt->u.spectrum_notif);
2511
2512 if (!report->state) {
2513 D_11H(
2514 "Spectrum Measure Notification: Start\n");
2515 return;
2516 }
2517
2518 memcpy(&il->measure_report, report, sizeof(*report));
2519 il->measurement_status |= MEASUREMENT_READY;
2520}
2521EXPORT_SYMBOL(il_hdl_spectrum_measurement);
2522
2523/*
2524 * returns non-zero if packet should be dropped
2525 */
2526int il_set_decrypted_flag(struct il_priv *il,
2527 struct ieee80211_hdr *hdr,
2528 u32 decrypt_res,
2529 struct ieee80211_rx_status *stats)
2530{
2531 u16 fc = le16_to_cpu(hdr->frame_control);
2532
2533 /*
2534 * All contexts have the same setting here due to it being
2535 * a module parameter, so OK to check any context.
2536 */
2537 if (il->ctx.active.filter_flags &
2538 RXON_FILTER_DIS_DECRYPT_MSK)
2539 return 0;
2540
2541 if (!(fc & IEEE80211_FCTL_PROTECTED))
2542 return 0;
2543
2544 D_RX("decrypt_res:0x%x\n", decrypt_res);
2545 switch (decrypt_res & RX_RES_STATUS_SEC_TYPE_MSK) {
2546 case RX_RES_STATUS_SEC_TYPE_TKIP:
2547 /* The uCode has got a bad phase 1 Key, pushes the packet.
2548 * Decryption will be done in SW. */
2549 if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
2550 RX_RES_STATUS_BAD_KEY_TTAK)
2551 break;
2552
2553 case RX_RES_STATUS_SEC_TYPE_WEP:
2554 if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
2555 RX_RES_STATUS_BAD_ICV_MIC) {
2556 /* bad ICV, the packet is destroyed since the
2557 * decryption is inplace, drop it */
2558 D_RX("Packet destroyed\n");
2559 return -1;
2560 }
2561 case RX_RES_STATUS_SEC_TYPE_CCMP:
2562 if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
2563 RX_RES_STATUS_DECRYPT_OK) {
2564 D_RX("hw decrypt successfully!!!\n");
2565 stats->flag |= RX_FLAG_DECRYPTED;
2566 }
2567 break;
2568
2569 default:
2570 break;
2571 }
2572 return 0;
2573}
2574EXPORT_SYMBOL(il_set_decrypted_flag);
2575
2576/**
2577 * il_txq_update_write_ptr - Send new write idx to hardware
2578 */
2579void
2580il_txq_update_write_ptr(struct il_priv *il, struct il_tx_queue *txq)
2581{
2582 u32 reg = 0;
2583 int txq_id = txq->q.id;
2584
2585 if (txq->need_update == 0)
2586 return;
2587
2588 /* if we're trying to save power */
2589 if (test_bit(S_POWER_PMI, &il->status)) {
2590 /* wake up nic if it's powered down ...
2591 * uCode will wake up, and interrupt us again, so next
2592 * time we'll skip this part. */
2593 reg = _il_rd(il, CSR_UCODE_DRV_GP1);
2594
2595 if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
2596 D_INFO(
2597 "Tx queue %d requesting wakeup,"
2598 " GP1 = 0x%x\n", txq_id, reg);
2599 il_set_bit(il, CSR_GP_CNTRL,
2600 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
2601 return;
2602 }
2603
2604 il_wr(il, HBUS_TARG_WRPTR,
2605 txq->q.write_ptr | (txq_id << 8));
2606
2607 /*
2608 * else not in power-save mode,
2609 * uCode will never sleep when we're
2610 * trying to tx (during RFKILL, we're not trying to tx).
2611 */
2612 } else
2613 _il_wr(il, HBUS_TARG_WRPTR,
2614 txq->q.write_ptr | (txq_id << 8));
2615 txq->need_update = 0;
2616}
2617EXPORT_SYMBOL(il_txq_update_write_ptr);
2618
2619/**
2620 * il_tx_queue_unmap - Unmap any remaining DMA mappings and free skb's
2621 */
2622void il_tx_queue_unmap(struct il_priv *il, int txq_id)
2623{
2624 struct il_tx_queue *txq = &il->txq[txq_id];
2625 struct il_queue *q = &txq->q;
2626
2627 if (q->n_bd == 0)
2628 return;
2629
2630 while (q->write_ptr != q->read_ptr) {
2631 il->cfg->ops->lib->txq_free_tfd(il, txq);
2632 q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd);
2633 }
2634}
2635EXPORT_SYMBOL(il_tx_queue_unmap);
2636
2637/**
2638 * il_tx_queue_free - Deallocate DMA queue.
2639 * @txq: Transmit queue to deallocate.
2640 *
2641 * Empty queue by removing and destroying all BD's.
2642 * Free all buffers.
2643 * 0-fill, but do not free "txq" descriptor structure.
2644 */
2645void il_tx_queue_free(struct il_priv *il, int txq_id)
2646{
2647 struct il_tx_queue *txq = &il->txq[txq_id];
2648 struct device *dev = &il->pci_dev->dev;
2649 int i;
2650
2651 il_tx_queue_unmap(il, txq_id);
2652
2653 /* De-alloc array of command/tx buffers */
2654 for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
2655 kfree(txq->cmd[i]);
2656
2657 /* De-alloc circular buffer of TFDs */
2658 if (txq->q.n_bd)
2659 dma_free_coherent(dev, il->hw_params.tfd_size *
2660 txq->q.n_bd, txq->tfds, txq->q.dma_addr);
2661
2662 /* De-alloc array of per-TFD driver data */
2663 kfree(txq->txb);
2664 txq->txb = NULL;
2665
2666 /* deallocate arrays */
2667 kfree(txq->cmd);
2668 kfree(txq->meta);
2669 txq->cmd = NULL;
2670 txq->meta = NULL;
2671
2672 /* 0-fill queue descriptor structure */
2673 memset(txq, 0, sizeof(*txq));
2674}
2675EXPORT_SYMBOL(il_tx_queue_free);
2676
2677/**
2678 * il_cmd_queue_unmap - Unmap any remaining DMA mappings from command queue
2679 */
2680void il_cmd_queue_unmap(struct il_priv *il)
2681{
2682 struct il_tx_queue *txq = &il->txq[il->cmd_queue];
2683 struct il_queue *q = &txq->q;
2684 int i;
2685
2686 if (q->n_bd == 0)
2687 return;
2688
2689 while (q->read_ptr != q->write_ptr) {
2690 i = il_get_cmd_idx(q, q->read_ptr, 0);
2691
2692 if (txq->meta[i].flags & CMD_MAPPED) {
2693 pci_unmap_single(il->pci_dev,
2694 dma_unmap_addr(&txq->meta[i], mapping),
2695 dma_unmap_len(&txq->meta[i], len),
2696 PCI_DMA_BIDIRECTIONAL);
2697 txq->meta[i].flags = 0;
2698 }
2699
2700 q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd);
2701 }
2702
2703 i = q->n_win;
2704 if (txq->meta[i].flags & CMD_MAPPED) {
2705 pci_unmap_single(il->pci_dev,
2706 dma_unmap_addr(&txq->meta[i], mapping),
2707 dma_unmap_len(&txq->meta[i], len),
2708 PCI_DMA_BIDIRECTIONAL);
2709 txq->meta[i].flags = 0;
2710 }
2711}
2712EXPORT_SYMBOL(il_cmd_queue_unmap);
2713
2714/**
2715 * il_cmd_queue_free - Deallocate DMA queue.
2716 * @txq: Transmit queue to deallocate.
2717 *
2718 * Empty queue by removing and destroying all BD's.
2719 * Free all buffers.
2720 * 0-fill, but do not free "txq" descriptor structure.
2721 */
2722void il_cmd_queue_free(struct il_priv *il)
2723{
2724 struct il_tx_queue *txq = &il->txq[il->cmd_queue];
2725 struct device *dev = &il->pci_dev->dev;
2726 int i;
2727
2728 il_cmd_queue_unmap(il);
2729
2730 /* De-alloc array of command/tx buffers */
2731 for (i = 0; i <= TFD_CMD_SLOTS; i++)
2732 kfree(txq->cmd[i]);
2733
2734 /* De-alloc circular buffer of TFDs */
2735 if (txq->q.n_bd)
2736 dma_free_coherent(dev, il->hw_params.tfd_size * txq->q.n_bd,
2737 txq->tfds, txq->q.dma_addr);
2738
2739 /* deallocate arrays */
2740 kfree(txq->cmd);
2741 kfree(txq->meta);
2742 txq->cmd = NULL;
2743 txq->meta = NULL;
2744
2745 /* 0-fill queue descriptor structure */
2746 memset(txq, 0, sizeof(*txq));
2747}
2748EXPORT_SYMBOL(il_cmd_queue_free);
2749
2750/*************** DMA-QUEUE-GENERAL-FUNCTIONS *****
2751 * DMA services
2752 *
2753 * Theory of operation
2754 *
2755 * A Tx or Rx queue resides in host DRAM, and is comprised of a circular buffer
2756 * of buffer descriptors, each of which points to one or more data buffers for
2757 * the device to read from or fill. Driver and device exchange status of each
2758 * queue via "read" and "write" pointers. Driver keeps minimum of 2 empty
2759 * entries in each circular buffer, to protect against confusing empty and full
2760 * queue states.
2761 *
2762 * The device reads or writes the data in the queues via the device's several
2763 * DMA/FIFO channels. Each queue is mapped to a single DMA channel.
2764 *
2765 * For Tx queue, there are low mark and high mark limits. If, after queuing
2766 * the packet for Tx, free space become < low mark, Tx queue stopped. When
2767 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
2768 * Tx queue resumed.
2769 *
2770 * See more detailed info in 4965.h.
2771 ***************************************************/
2772
2773int il_queue_space(const struct il_queue *q)
2774{
2775 int s = q->read_ptr - q->write_ptr;
2776
2777 if (q->read_ptr > q->write_ptr)
2778 s -= q->n_bd;
2779
2780 if (s <= 0)
2781 s += q->n_win;
2782 /* keep some reserve to not confuse empty and full situations */
2783 s -= 2;
2784 if (s < 0)
2785 s = 0;
2786 return s;
2787}
2788EXPORT_SYMBOL(il_queue_space);
2789
2790
2791/**
2792 * il_queue_init - Initialize queue's high/low-water and read/write idxes
2793 */
2794static int il_queue_init(struct il_priv *il, struct il_queue *q,
2795 int count, int slots_num, u32 id)
2796{
2797 q->n_bd = count;
2798 q->n_win = slots_num;
2799 q->id = id;
2800
2801 /* count must be power-of-two size, otherwise il_queue_inc_wrap
2802 * and il_queue_dec_wrap are broken. */
2803 BUG_ON(!is_power_of_2(count));
2804
2805 /* slots_num must be power-of-two size, otherwise
2806 * il_get_cmd_idx is broken. */
2807 BUG_ON(!is_power_of_2(slots_num));
2808
2809 q->low_mark = q->n_win / 4;
2810 if (q->low_mark < 4)
2811 q->low_mark = 4;
2812
2813 q->high_mark = q->n_win / 8;
2814 if (q->high_mark < 2)
2815 q->high_mark = 2;
2816
2817 q->write_ptr = q->read_ptr = 0;
2818
2819 return 0;
2820}
2821
2822/**
2823 * il_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
2824 */
2825static int il_tx_queue_alloc(struct il_priv *il,
2826 struct il_tx_queue *txq, u32 id)
2827{
2828 struct device *dev = &il->pci_dev->dev;
2829 size_t tfd_sz = il->hw_params.tfd_size * TFD_QUEUE_SIZE_MAX;
2830
2831 /* Driver ilate data, only for Tx (not command) queues,
2832 * not shared with device. */
2833 if (id != il->cmd_queue) {
2834 txq->txb = kzalloc(sizeof(txq->txb[0]) *
2835 TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
2836 if (!txq->txb) {
2837 IL_ERR("kmalloc for auxiliary BD "
2838 "structures failed\n");
2839 goto error;
2840 }
2841 } else {
2842 txq->txb = NULL;
2843 }
2844
2845 /* Circular buffer of transmit frame descriptors (TFDs),
2846 * shared with device */
2847 txq->tfds = dma_alloc_coherent(dev, tfd_sz, &txq->q.dma_addr,
2848 GFP_KERNEL);
2849 if (!txq->tfds) {
2850 IL_ERR("pci_alloc_consistent(%zd) failed\n", tfd_sz);
2851 goto error;
2852 }
2853 txq->q.id = id;
2854
2855 return 0;
2856
2857 error:
2858 kfree(txq->txb);
2859 txq->txb = NULL;
2860
2861 return -ENOMEM;
2862}
2863
2864/**
2865 * il_tx_queue_init - Allocate and initialize one tx/cmd queue
2866 */
2867int il_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq,
2868 int slots_num, u32 txq_id)
2869{
2870 int i, len;
2871 int ret;
2872 int actual_slots = slots_num;
2873
2874 /*
2875 * Alloc buffer array for commands (Tx or other types of commands).
2876 * For the command queue (#4/#9), allocate command space + one big
2877 * command for scan, since scan command is very huge; the system will
2878 * not have two scans at the same time, so only one is needed.
2879 * For normal Tx queues (all other queues), no super-size command
2880 * space is needed.
2881 */
2882 if (txq_id == il->cmd_queue)
2883 actual_slots++;
2884
2885 txq->meta = kzalloc(sizeof(struct il_cmd_meta) * actual_slots,
2886 GFP_KERNEL);
2887 txq->cmd = kzalloc(sizeof(struct il_device_cmd *) * actual_slots,
2888 GFP_KERNEL);
2889
2890 if (!txq->meta || !txq->cmd)
2891 goto out_free_arrays;
2892
2893 len = sizeof(struct il_device_cmd);
2894 for (i = 0; i < actual_slots; i++) {
2895 /* only happens for cmd queue */
2896 if (i == slots_num)
2897 len = IL_MAX_CMD_SIZE;
2898
2899 txq->cmd[i] = kmalloc(len, GFP_KERNEL);
2900 if (!txq->cmd[i])
2901 goto err;
2902 }
2903
2904 /* Alloc driver data array and TFD circular buffer */
2905 ret = il_tx_queue_alloc(il, txq, txq_id);
2906 if (ret)
2907 goto err;
2908
2909 txq->need_update = 0;
2910
2911 /*
2912 * For the default queues 0-3, set up the swq_id
2913 * already -- all others need to get one later
2914 * (if they need one at all).
2915 */
2916 if (txq_id < 4)
2917 il_set_swq_id(txq, txq_id, txq_id);
2918
2919 /* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
2920 * il_queue_inc_wrap and il_queue_dec_wrap are broken. */
2921 BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
2922
2923 /* Initialize queue's high/low-water marks, and head/tail idxes */
2924 il_queue_init(il, &txq->q,
2925 TFD_QUEUE_SIZE_MAX, slots_num, txq_id);
2926
2927 /* Tell device where to find queue */
2928 il->cfg->ops->lib->txq_init(il, txq);
2929
2930 return 0;
2931err:
2932 for (i = 0; i < actual_slots; i++)
2933 kfree(txq->cmd[i]);
2934out_free_arrays:
2935 kfree(txq->meta);
2936 kfree(txq->cmd);
2937
2938 return -ENOMEM;
2939}
2940EXPORT_SYMBOL(il_tx_queue_init);
2941
2942void il_tx_queue_reset(struct il_priv *il, struct il_tx_queue *txq,
2943 int slots_num, u32 txq_id)
2944{
2945 int actual_slots = slots_num;
2946
2947 if (txq_id == il->cmd_queue)
2948 actual_slots++;
2949
2950 memset(txq->meta, 0, sizeof(struct il_cmd_meta) * actual_slots);
2951
2952 txq->need_update = 0;
2953
2954 /* Initialize queue's high/low-water marks, and head/tail idxes */
2955 il_queue_init(il, &txq->q,
2956 TFD_QUEUE_SIZE_MAX, slots_num, txq_id);
2957
2958 /* Tell device where to find queue */
2959 il->cfg->ops->lib->txq_init(il, txq);
2960}
2961EXPORT_SYMBOL(il_tx_queue_reset);
2962
2963/*************** HOST COMMAND QUEUE FUNCTIONS *****/
2964
2965/**
2966 * il_enqueue_hcmd - enqueue a uCode command
2967 * @il: device ilate data point
2968 * @cmd: a point to the ucode command structure
2969 *
2970 * The function returns < 0 values to indicate the operation is
2971 * failed. On success, it turns the idx (> 0) of command in the
2972 * command queue.
2973 */
2974int il_enqueue_hcmd(struct il_priv *il, struct il_host_cmd *cmd)
2975{
2976 struct il_tx_queue *txq = &il->txq[il->cmd_queue];
2977 struct il_queue *q = &txq->q;
2978 struct il_device_cmd *out_cmd;
2979 struct il_cmd_meta *out_meta;
2980 dma_addr_t phys_addr;
2981 unsigned long flags;
2982 int len;
2983 u32 idx;
2984 u16 fix_size;
2985
2986 cmd->len = il->cfg->ops->utils->get_hcmd_size(cmd->id, cmd->len);
2987 fix_size = (u16)(cmd->len + sizeof(out_cmd->hdr));
2988
2989 /* If any of the command structures end up being larger than
2990 * the TFD_MAX_PAYLOAD_SIZE, and it sent as a 'small' command then
2991 * we will need to increase the size of the TFD entries
2992 * Also, check to see if command buffer should not exceed the size
2993 * of device_cmd and max_cmd_size. */
2994 BUG_ON((fix_size > TFD_MAX_PAYLOAD_SIZE) &&
2995 !(cmd->flags & CMD_SIZE_HUGE));
2996 BUG_ON(fix_size > IL_MAX_CMD_SIZE);
2997
2998 if (il_is_rfkill(il) || il_is_ctkill(il)) {
2999 IL_WARN("Not sending command - %s KILL\n",
3000 il_is_rfkill(il) ? "RF" : "CT");
3001 return -EIO;
3002 }
3003
3004 spin_lock_irqsave(&il->hcmd_lock, flags);
3005
3006 if (il_queue_space(q) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {
3007 spin_unlock_irqrestore(&il->hcmd_lock, flags);
3008
3009 IL_ERR("Restarting adapter due to command queue full\n");
3010 queue_work(il->workqueue, &il->restart);
3011 return -ENOSPC;
3012 }
3013
3014 idx = il_get_cmd_idx(q, q->write_ptr, cmd->flags & CMD_SIZE_HUGE);
3015 out_cmd = txq->cmd[idx];
3016 out_meta = &txq->meta[idx];
3017
3018 if (WARN_ON(out_meta->flags & CMD_MAPPED)) {
3019 spin_unlock_irqrestore(&il->hcmd_lock, flags);
3020 return -ENOSPC;
3021 }
3022
3023 memset(out_meta, 0, sizeof(*out_meta)); /* re-initialize to NULL */
3024 out_meta->flags = cmd->flags | CMD_MAPPED;
3025 if (cmd->flags & CMD_WANT_SKB)
3026 out_meta->source = cmd;
3027 if (cmd->flags & CMD_ASYNC)
3028 out_meta->callback = cmd->callback;
3029
3030 out_cmd->hdr.cmd = cmd->id;
3031 memcpy(&out_cmd->cmd.payload, cmd->data, cmd->len);
3032
3033 /* At this point, the out_cmd now has all of the incoming cmd
3034 * information */
3035
3036 out_cmd->hdr.flags = 0;
3037 out_cmd->hdr.sequence = cpu_to_le16(QUEUE_TO_SEQ(il->cmd_queue) |
3038 IDX_TO_SEQ(q->write_ptr));
3039 if (cmd->flags & CMD_SIZE_HUGE)
3040 out_cmd->hdr.sequence |= SEQ_HUGE_FRAME;
3041 len = sizeof(struct il_device_cmd);
3042 if (idx == TFD_CMD_SLOTS)
3043 len = IL_MAX_CMD_SIZE;
3044
3045#ifdef CONFIG_IWLEGACY_DEBUG
3046 switch (out_cmd->hdr.cmd) {
3047 case C_TX_LINK_QUALITY_CMD:
3048 case C_SENSITIVITY:
3049 D_HC_DUMP(
3050 "Sending command %s (#%x), seq: 0x%04X, "
3051 "%d bytes at %d[%d]:%d\n",
3052 il_get_cmd_string(out_cmd->hdr.cmd),
3053 out_cmd->hdr.cmd,
3054 le16_to_cpu(out_cmd->hdr.sequence), fix_size,
3055 q->write_ptr, idx, il->cmd_queue);
3056 break;
3057 default:
3058 D_HC("Sending command %s (#%x), seq: 0x%04X, "
3059 "%d bytes at %d[%d]:%d\n",
3060 il_get_cmd_string(out_cmd->hdr.cmd),
3061 out_cmd->hdr.cmd,
3062 le16_to_cpu(out_cmd->hdr.sequence), fix_size,
3063 q->write_ptr, idx, il->cmd_queue);
3064 }
3065#endif
3066 txq->need_update = 1;
3067
3068 if (il->cfg->ops->lib->txq_update_byte_cnt_tbl)
3069 /* Set up entry in queue's byte count circular buffer */
3070 il->cfg->ops->lib->txq_update_byte_cnt_tbl(il, txq, 0);
3071
3072 phys_addr = pci_map_single(il->pci_dev, &out_cmd->hdr,
3073 fix_size, PCI_DMA_BIDIRECTIONAL);
3074 dma_unmap_addr_set(out_meta, mapping, phys_addr);
3075 dma_unmap_len_set(out_meta, len, fix_size);
3076
3077 il->cfg->ops->lib->txq_attach_buf_to_tfd(il, txq,
3078 phys_addr, fix_size, 1,
3079 U32_PAD(cmd->len));
3080
3081 /* Increment and update queue's write idx */
3082 q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
3083 il_txq_update_write_ptr(il, txq);
3084
3085 spin_unlock_irqrestore(&il->hcmd_lock, flags);
3086 return idx;
3087}
3088
3089/**
3090 * il_hcmd_queue_reclaim - Reclaim TX command queue entries already Tx'd
3091 *
3092 * When FW advances 'R' idx, all entries between old and new 'R' idx
3093 * need to be reclaimed. As result, some free space forms. If there is
3094 * enough free space (> low mark), wake the stack that feeds us.
3095 */
3096static void il_hcmd_queue_reclaim(struct il_priv *il, int txq_id,
3097 int idx, int cmd_idx)
3098{
3099 struct il_tx_queue *txq = &il->txq[txq_id];
3100 struct il_queue *q = &txq->q;
3101 int nfreed = 0;
3102
3103 if (idx >= q->n_bd || il_queue_used(q, idx) == 0) {
3104 IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
3105 "is out of range [0-%d] %d %d.\n", txq_id,
3106 idx, q->n_bd, q->write_ptr, q->read_ptr);
3107 return;
3108 }
3109
3110 for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
3111 q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {
3112
3113 if (nfreed++ > 0) {
3114 IL_ERR("HCMD skipped: idx (%d) %d %d\n", idx,
3115 q->write_ptr, q->read_ptr);
3116 queue_work(il->workqueue, &il->restart);
3117 }
3118
3119 }
3120}
3121
3122/**
3123 * il_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
3124 * @rxb: Rx buffer to reclaim
3125 *
3126 * If an Rx buffer has an async callback associated with it the callback
3127 * will be executed. The attached skb (if present) will only be freed
3128 * if the callback returns 1
3129 */
3130void
3131il_tx_cmd_complete(struct il_priv *il, struct il_rx_buf *rxb)
3132{
3133 struct il_rx_pkt *pkt = rxb_addr(rxb);
3134 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
3135 int txq_id = SEQ_TO_QUEUE(sequence);
3136 int idx = SEQ_TO_IDX(sequence);
3137 int cmd_idx;
3138 bool huge = !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
3139 struct il_device_cmd *cmd;
3140 struct il_cmd_meta *meta;
3141 struct il_tx_queue *txq = &il->txq[il->cmd_queue];
3142 unsigned long flags;
3143
3144 /* If a Tx command is being handled and it isn't in the actual
3145 * command queue then there a command routing bug has been introduced
3146 * in the queue management code. */
3147 if (WARN(txq_id != il->cmd_queue,
3148 "wrong command queue %d (should be %d), sequence 0x%X readp=%d writep=%d\n",
3149 txq_id, il->cmd_queue, sequence,
3150 il->txq[il->cmd_queue].q.read_ptr,
3151 il->txq[il->cmd_queue].q.write_ptr)) {
3152 il_print_hex_error(il, pkt, 32);
3153 return;
3154 }
3155
3156 cmd_idx = il_get_cmd_idx(&txq->q, idx, huge);
3157 cmd = txq->cmd[cmd_idx];
3158 meta = &txq->meta[cmd_idx];
3159
3160 txq->time_stamp = jiffies;
3161
3162 pci_unmap_single(il->pci_dev,
3163 dma_unmap_addr(meta, mapping),
3164 dma_unmap_len(meta, len),
3165 PCI_DMA_BIDIRECTIONAL);
3166
3167 /* Input error checking is done when commands are added to queue. */
3168 if (meta->flags & CMD_WANT_SKB) {
3169 meta->source->reply_page = (unsigned long)rxb_addr(rxb);
3170 rxb->page = NULL;
3171 } else if (meta->callback)
3172 meta->callback(il, cmd, pkt);
3173
3174 spin_lock_irqsave(&il->hcmd_lock, flags);
3175
3176 il_hcmd_queue_reclaim(il, txq_id, idx, cmd_idx);
3177
3178 if (!(meta->flags & CMD_ASYNC)) {
3179 clear_bit(S_HCMD_ACTIVE, &il->status);
3180 D_INFO("Clearing HCMD_ACTIVE for command %s\n",
3181 il_get_cmd_string(cmd->hdr.cmd));
3182 wake_up(&il->wait_command_queue);
3183 }
3184
3185 /* Mark as unmapped */
3186 meta->flags = 0;
3187
3188 spin_unlock_irqrestore(&il->hcmd_lock, flags);
3189}
3190EXPORT_SYMBOL(il_tx_cmd_complete);
45 3191
46MODULE_DESCRIPTION("iwl-legacy: common functions for 3945 and 4965"); 3192MODULE_DESCRIPTION("iwl-legacy: common functions for 3945 and 4965");
47MODULE_VERSION(IWLWIFI_VERSION); 3193MODULE_VERSION(IWLWIFI_VERSION);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-24 11:30:22 -0500