← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/net/wireless/iwmc3200wifi/main.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/wireless/iwmc3200wifi/main.c
 
1
/*
 
2
 * Intel Wireless Multicomm 3200 WiFi driver
 
3
 *
 
4
 * Copyright (C) 2009 Intel Corporation. All rights reserved.
 
5
 *
 
6
 * Redistribution and use in source and binary forms, with or without
 
7
 * modification, are permitted provided that the following conditions
 
8
 * are met:
 
9
 *
 
10
 *   * Redistributions of source code must retain the above copyright
 
11
 *     notice, this list of conditions and the following disclaimer.
 
12
 *   * Redistributions in binary form must reproduce the above copyright
 
13
 *     notice, this list of conditions and the following disclaimer in
 
14
 *     the documentation and/or other materials provided with the
 
15
 *     distribution.
 
16
 *   * Neither the name of Intel Corporation nor the names of its
 
17
 *     contributors may be used to endorse or promote products derived
 
18
 *     from this software without specific prior written permission.
 
19
 *
 
20
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
21
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
22
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
23
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
24
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
25
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
26
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
27
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
28
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
29
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
30
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
31
 *
 
32
 *
 
33
 * Intel Corporation <ilw@linux.intel.com>
 
34
 * Samuel Ortiz <samuel.ortiz@intel.com>
 
35
 * Zhu Yi <yi.zhu@intel.com>
 
36
 *
 
37
 */
 
38
 
 
39
#include <linux/kernel.h>
 
40
#include <linux/netdevice.h>
 
41
#include <linux/sched.h>
 
42
#include <linux/ieee80211.h>
 
43
#include <linux/wireless.h>
 
44
#include <linux/slab.h>
 
45
#include <linux/moduleparam.h>
 
46
 
 
47
#include "iwm.h"
 
48
#include "debug.h"
 
49
#include "bus.h"
 
50
#include "umac.h"
 
51
#include "commands.h"
 
52
#include "hal.h"
 
53
#include "fw.h"
 
54
#include "rx.h"
 
55
 
 
56
static struct iwm_conf def_iwm_conf = {
 
57
 
 
58
        .sdio_ior_timeout       = 5000,
 
59
        .calib_map              = BIT(CALIB_CFG_DC_IDX) |
 
60
                                  BIT(CALIB_CFG_LO_IDX) |
 
61
                                  BIT(CALIB_CFG_TX_IQ_IDX)      |
 
62
                                  BIT(CALIB_CFG_RX_IQ_IDX)      |
 
63
                                  BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD),
 
64
        .expected_calib_map     = BIT(PHY_CALIBRATE_DC_CMD)     |
 
65
                                  BIT(PHY_CALIBRATE_LO_CMD)     |
 
66
                                  BIT(PHY_CALIBRATE_TX_IQ_CMD)  |
 
67
                                  BIT(PHY_CALIBRATE_RX_IQ_CMD)  |
 
68
                                  BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD),
 
69
        .ct_kill_entry          = 110,
 
70
        .ct_kill_exit           = 110,
 
71
        .reset_on_fatal_err     = 1,
 
72
        .auto_connect           = 1,
 
73
        .enable_qos             = 1,
 
74
        .mode                   = UMAC_MODE_BSS,
 
75
 
 
76
        /* UMAC configuration */
 
77
        .power_index            = 0,
 
78
        .frag_threshold         = IEEE80211_MAX_FRAG_THRESHOLD,
 
79
        .rts_threshold          = IEEE80211_MAX_RTS_THRESHOLD,
 
80
        .cts_to_self            = 0,
 
81
 
 
82
        .assoc_timeout          = 2,
 
83
        .roam_timeout           = 10,
 
84
        .wireless_mode          = WIRELESS_MODE_11A | WIRELESS_MODE_11G |
 
85
                                  WIRELESS_MODE_11N,
 
86
 
 
87
        /* IBSS */
 
88
        .ibss_band              = UMAC_BAND_2GHZ,
 
89
        .ibss_channel           = 1,
 
90
 
 
91
        .mac_addr               = {0x00, 0x02, 0xb3, 0x01, 0x02, 0x03},
 
92
};
 
93
 
 
94
static int modparam_reset;
 
95
module_param_named(reset, modparam_reset, bool, 0644);
 
96
MODULE_PARM_DESC(reset, "reset on firmware errors (default 0 [not reset])");
 
97
 
 
98
static int modparam_wimax_enable = 1;
 
99
module_param_named(wimax_enable, modparam_wimax_enable, bool, 0644);
 
100
MODULE_PARM_DESC(wimax_enable, "Enable wimax core (default 1 [wimax enabled])");
 
101
 
 
102
int iwm_mode_to_nl80211_iftype(int mode)
 
103
{
 
104
        switch (mode) {
 
105
        case UMAC_MODE_BSS:
 
106
                return NL80211_IFTYPE_STATION;
 
107
        case UMAC_MODE_IBSS:
 
108
                return NL80211_IFTYPE_ADHOC;
 
109
        default:
 
110
                return NL80211_IFTYPE_UNSPECIFIED;
 
111
        }
 
112
 
 
113
        return 0;
 
114
}
 
115
 
 
116
static void iwm_statistics_request(struct work_struct *work)
 
117
{
 
118
        struct iwm_priv *iwm =
 
119
                container_of(work, struct iwm_priv, stats_request.work);
 
120
 
 
121
        iwm_send_umac_stats_req(iwm, 0);
 
122
}
 
123
 
 
124
static void iwm_disconnect_work(struct work_struct *work)
 
125
{
 
126
        struct iwm_priv *iwm =
 
127
                container_of(work, struct iwm_priv, disconnect.work);
 
128
 
 
129
        if (iwm->umac_profile_active)
 
130
                iwm_invalidate_mlme_profile(iwm);
 
131
 
 
132
        clear_bit(IWM_STATUS_ASSOCIATED, &iwm->status);
 
133
        iwm->umac_profile_active = 0;
 
134
        memset(iwm->bssid, 0, ETH_ALEN);
 
135
        iwm->channel = 0;
 
136
 
 
137
        iwm_link_off(iwm);
 
138
 
 
139
        wake_up_interruptible(&iwm->mlme_queue);
 
140
 
 
141
        cfg80211_disconnected(iwm_to_ndev(iwm), 0, NULL, 0, GFP_KERNEL);
 
142
}
 
143
 
 
144
static void iwm_ct_kill_work(struct work_struct *work)
 
145
{
 
146
        struct iwm_priv *iwm =
 
147
                container_of(work, struct iwm_priv, ct_kill_delay.work);
 
148
        struct wiphy *wiphy = iwm_to_wiphy(iwm);
 
149
 
 
150
        IWM_INFO(iwm, "CT kill delay timeout\n");
 
151
 
 
152
        wiphy_rfkill_set_hw_state(wiphy, false);
 
153
}
 
154
 
 
155
static int __iwm_up(struct iwm_priv *iwm);
 
156
static int __iwm_down(struct iwm_priv *iwm);
 
157
 
 
158
static void iwm_reset_worker(struct work_struct *work)
 
159
{
 
160
        struct iwm_priv *iwm;
 
161
        struct iwm_umac_profile *profile = NULL;
 
162
        int uninitialized_var(ret), retry = 0;
 
163
 
 
164
        iwm = container_of(work, struct iwm_priv, reset_worker);
 
165
 
 
166
        /*
 
167
         * XXX: The iwm->mutex is introduced purely for this reset work,
 
168
         * because the other users for iwm_up and iwm_down are only netdev
 
169
         * ndo_open and ndo_stop which are already protected by rtnl.
 
170
         * Please remove iwm->mutex together if iwm_reset_worker() is not
 
171
         * required in the future.
 
172
         */
 
173
        if (!mutex_trylock(&iwm->mutex)) {
 
174
                IWM_WARN(iwm, "We are in the middle of interface bringing "
 
175
                         "UP/DOWN. Skip driver resetting.\n");
 
176
                return;
 
177
        }
 
178
 
 
179
        if (iwm->umac_profile_active) {
 
180
                profile = kmalloc(sizeof(struct iwm_umac_profile), GFP_KERNEL);
 
181
                if (profile)
 
182
                        memcpy(profile, iwm->umac_profile, sizeof(*profile));
 
183
                else
 
184
                        IWM_ERR(iwm, "Couldn't alloc memory for profile\n");
 
185
        }
 
186
 
 
187
        __iwm_down(iwm);
 
188
 
 
189
        while (retry++ < 3) {
 
190
                ret = __iwm_up(iwm);
 
191
                if (!ret)
 
192
                        break;
 
193
 
 
194
                schedule_timeout_uninterruptible(10 * HZ);
 
195
        }
 
196
 
 
197
        if (ret) {
 
198
                IWM_WARN(iwm, "iwm_up() failed: %d\n", ret);
 
199
 
 
200
                kfree(profile);
 
201
                goto out;
 
202
        }
 
203
 
 
204
        if (profile) {
 
205
                IWM_DBG_MLME(iwm, DBG, "Resend UMAC profile\n");
 
206
                memcpy(iwm->umac_profile, profile, sizeof(*profile));
 
207
                iwm_send_mlme_profile(iwm);
 
208
                kfree(profile);
 
209
        } else
 
210
                clear_bit(IWM_STATUS_RESETTING, &iwm->status);
 
211
 
 
212
 out:
 
213
        mutex_unlock(&iwm->mutex);
 
214
}
 
215
 
 
216
static void iwm_auth_retry_worker(struct work_struct *work)
 
217
{
 
218
        struct iwm_priv *iwm;
 
219
        int i, ret;
 
220
 
 
221
        iwm = container_of(work, struct iwm_priv, auth_retry_worker);
 
222
        if (iwm->umac_profile_active) {
 
223
                ret = iwm_invalidate_mlme_profile(iwm);
 
224
                if (ret < 0)
 
225
                        return;
 
226
        }
 
227
 
 
228
        iwm->umac_profile->sec.auth_type = UMAC_AUTH_TYPE_LEGACY_PSK;
 
229
 
 
230
        ret = iwm_send_mlme_profile(iwm);
 
231
        if (ret < 0)
 
232
                return;
 
233
 
 
234
        for (i = 0; i < IWM_NUM_KEYS; i++)
 
235
                if (iwm->keys[i].key_len)
 
236
                        iwm_set_key(iwm, 0, &iwm->keys[i]);
 
237
 
 
238
        iwm_set_tx_key(iwm, iwm->default_key);
 
239
}
 
240
 
 
241
 
 
242
 
 
243
static void iwm_watchdog(unsigned long data)
 
244
{
 
245
        struct iwm_priv *iwm = (struct iwm_priv *)data;
 
246
 
 
247
        IWM_WARN(iwm, "Watchdog expired: UMAC stalls!\n");
 
248
 
 
249
        if (modparam_reset)
 
250
                iwm_resetting(iwm);
 
251
}
 
252
 
 
253
int iwm_priv_init(struct iwm_priv *iwm)
 
254
{
 
255
        int i, j;
 
256
        char name[32];
 
257
 
 
258
        iwm->status = 0;
 
259
        INIT_LIST_HEAD(&iwm->pending_notif);
 
260
        init_waitqueue_head(&iwm->notif_queue);
 
261
        init_waitqueue_head(&iwm->nonwifi_queue);
 
262
        init_waitqueue_head(&iwm->wifi_ntfy_queue);
 
263
        init_waitqueue_head(&iwm->mlme_queue);
 
264
        memcpy(&iwm->conf, &def_iwm_conf, sizeof(struct iwm_conf));
 
265
        spin_lock_init(&iwm->tx_credit.lock);
 
266
        INIT_LIST_HEAD(&iwm->wifi_pending_cmd);
 
267
        INIT_LIST_HEAD(&iwm->nonwifi_pending_cmd);
 
268
        iwm->wifi_seq_num = UMAC_WIFI_SEQ_NUM_BASE;
 
269
        iwm->nonwifi_seq_num = UMAC_NONWIFI_SEQ_NUM_BASE;
 
270
        spin_lock_init(&iwm->cmd_lock);
 
271
        iwm->scan_id = 1;
 
272
        INIT_DELAYED_WORK(&iwm->stats_request, iwm_statistics_request);
 
273
        INIT_DELAYED_WORK(&iwm->disconnect, iwm_disconnect_work);
 
274
        INIT_DELAYED_WORK(&iwm->ct_kill_delay, iwm_ct_kill_work);
 
275
        INIT_WORK(&iwm->reset_worker, iwm_reset_worker);
 
276
        INIT_WORK(&iwm->auth_retry_worker, iwm_auth_retry_worker);
 
277
        INIT_LIST_HEAD(&iwm->bss_list);
 
278
 
 
279
        skb_queue_head_init(&iwm->rx_list);
 
280
        INIT_LIST_HEAD(&iwm->rx_tickets);
 
281
        spin_lock_init(&iwm->ticket_lock);
 
282
        for (i = 0; i < IWM_RX_ID_HASH; i++) {
 
283
                INIT_LIST_HEAD(&iwm->rx_packets[i]);
 
284
                spin_lock_init(&iwm->packet_lock[i]);
 
285
        }
 
286
 
 
287
        INIT_WORK(&iwm->rx_worker, iwm_rx_worker);
 
288
 
 
289
        iwm->rx_wq = create_singlethread_workqueue(KBUILD_MODNAME "_rx");
 
290
        if (!iwm->rx_wq)
 
291
                return -EAGAIN;
 
292
 
 
293
        for (i = 0; i < IWM_TX_QUEUES; i++) {
 
294
                INIT_WORK(&iwm->txq[i].worker, iwm_tx_worker);
 
295
                snprintf(name, 32, KBUILD_MODNAME "_tx_%d", i);
 
296
                iwm->txq[i].id = i;
 
297
                iwm->txq[i].wq = create_singlethread_workqueue(name);
 
298
                if (!iwm->txq[i].wq)
 
299
                        return -EAGAIN;
 
300
 
 
301
                skb_queue_head_init(&iwm->txq[i].queue);
 
302
                skb_queue_head_init(&iwm->txq[i].stopped_queue);
 
303
                spin_lock_init(&iwm->txq[i].lock);
 
304
        }
 
305
 
 
306
        for (i = 0; i < IWM_NUM_KEYS; i++)
 
307
                memset(&iwm->keys[i], 0, sizeof(struct iwm_key));
 
308
 
 
309
        iwm->default_key = -1;
 
310
 
 
311
        for (i = 0; i < IWM_STA_TABLE_NUM; i++)
 
312
                for (j = 0; j < IWM_UMAC_TID_NR; j++) {
 
313
                        mutex_init(&iwm->sta_table[i].tid_info[j].mutex);
 
314
                        iwm->sta_table[i].tid_info[j].stopped = false;
 
315
                }
 
316
 
 
317
        init_timer(&iwm->watchdog);
 
318
        iwm->watchdog.function = iwm_watchdog;
 
319
        iwm->watchdog.data = (unsigned long)iwm;
 
320
        mutex_init(&iwm->mutex);
 
321
 
 
322
        iwm->last_fw_err = kzalloc(sizeof(struct iwm_fw_error_hdr),
 
323
                                   GFP_KERNEL);
 
324
        if (iwm->last_fw_err == NULL)
 
325
                return -ENOMEM;
 
326
 
 
327
        return 0;
 
328
}
 
329
 
 
330
void iwm_priv_deinit(struct iwm_priv *iwm)
 
331
{
 
332
        int i;
 
333
 
 
334
        for (i = 0; i < IWM_TX_QUEUES; i++)
 
335
                destroy_workqueue(iwm->txq[i].wq);
 
336
 
 
337
        destroy_workqueue(iwm->rx_wq);
 
338
        kfree(iwm->last_fw_err);
 
339
}
 
340
 
 
341
/*
 
342
 * We reset all the structures, and we reset the UMAC.
 
343
 * After calling this routine, you're expected to reload
 
344
 * the firmware.
 
345
 */
 
346
void iwm_reset(struct iwm_priv *iwm)
 
347
{
 
348
        struct iwm_notif *notif, *next;
 
349
 
 
350
        if (test_bit(IWM_STATUS_READY, &iwm->status))
 
351
                iwm_target_reset(iwm);
 
352
 
 
353
        if (test_bit(IWM_STATUS_RESETTING, &iwm->status)) {
 
354
                iwm->status = 0;
 
355
                set_bit(IWM_STATUS_RESETTING, &iwm->status);
 
356
        } else
 
357
                iwm->status = 0;
 
358
        iwm->scan_id = 1;
 
359
 
 
360
        list_for_each_entry_safe(notif, next, &iwm->pending_notif, pending) {
 
361
                list_del(&notif->pending);
 
362
                kfree(notif->buf);
 
363
                kfree(notif);
 
364
        }
 
365
 
 
366
        iwm_cmd_flush(iwm);
 
367
 
 
368
        flush_workqueue(iwm->rx_wq);
 
369
 
 
370
        iwm_link_off(iwm);
 
371
}
 
372
 
 
373
void iwm_resetting(struct iwm_priv *iwm)
 
374
{
 
375
        set_bit(IWM_STATUS_RESETTING, &iwm->status);
 
376
 
 
377
        schedule_work(&iwm->reset_worker);
 
378
}
 
379
 
 
380
/*
 
381
 * Notification code:
 
382
 *
 
383
 * We're faced with the following issue: Any host command can
 
384
 * have an answer or not, and if there's an answer to expect,
 
385
 * it can be treated synchronously or asynchronously.
 
386
 * To work around the synchronous answer case, we implemented
 
387
 * our notification mechanism.
 
388
 * When a code path needs to wait for a command response
 
389
 * synchronously, it calls notif_handle(), which waits for the
 
390
 * right notification to show up, and then process it. Before
 
391
 * starting to wait, it registered as a waiter for this specific
 
392
 * answer (by toggling a bit in on of the handler_map), so that
 
393
 * the rx code knows that it needs to send a notification to the
 
394
 * waiting processes. It does so by calling iwm_notif_send(),
 
395
 * which adds the notification to the pending notifications list,
 
396
 * and then wakes the waiting processes up.
 
397
 */
 
398
int iwm_notif_send(struct iwm_priv *iwm, struct iwm_wifi_cmd *cmd,
 
399
                   u8 cmd_id, u8 source, u8 *buf, unsigned long buf_size)
 
400
{
 
401
        struct iwm_notif *notif;
 
402
 
 
403
        notif = kzalloc(sizeof(struct iwm_notif), GFP_KERNEL);
 
404
        if (!notif) {
 
405
                IWM_ERR(iwm, "Couldn't alloc memory for notification\n");
 
406
                return -ENOMEM;
 
407
        }
 
408
 
 
409
        INIT_LIST_HEAD(&notif->pending);
 
410
        notif->cmd = cmd;
 
411
        notif->cmd_id = cmd_id;
 
412
        notif->src = source;
 
413
        notif->buf = kzalloc(buf_size, GFP_KERNEL);
 
414
        if (!notif->buf) {
 
415
                IWM_ERR(iwm, "Couldn't alloc notification buffer\n");
 
416
                kfree(notif);
 
417
                return -ENOMEM;
 
418
        }
 
419
        notif->buf_size = buf_size;
 
420
        memcpy(notif->buf, buf, buf_size);
 
421
        list_add_tail(&notif->pending, &iwm->pending_notif);
 
422
 
 
423
        wake_up_interruptible(&iwm->notif_queue);
 
424
 
 
425
        return 0;
 
426
}
 
427
 
 
428
static struct iwm_notif *iwm_notif_find(struct iwm_priv *iwm, u32 cmd,
 
429
                                        u8 source)
 
430
{
 
431
        struct iwm_notif *notif;
 
432
 
 
433
        list_for_each_entry(notif, &iwm->pending_notif, pending) {
 
434
                if ((notif->cmd_id == cmd) && (notif->src == source)) {
 
435
                        list_del(&notif->pending);
 
436
                        return notif;
 
437
                }
 
438
        }
 
439
 
 
440
        return NULL;
 
441
}
 
442
 
 
443
static struct iwm_notif *iwm_notif_wait(struct iwm_priv *iwm, u32 cmd,
 
444
                                        u8 source, long timeout)
 
445
{
 
446
        int ret;
 
447
        struct iwm_notif *notif;
 
448
        unsigned long *map = NULL;
 
449
 
 
450
        switch (source) {
 
451
        case IWM_SRC_LMAC:
 
452
                map = &iwm->lmac_handler_map[0];
 
453
                break;
 
454
        case IWM_SRC_UMAC:
 
455
                map = &iwm->umac_handler_map[0];
 
456
                break;
 
457
        case IWM_SRC_UDMA:
 
458
                map = &iwm->udma_handler_map[0];
 
459
                break;
 
460
        }
 
461
 
 
462
        set_bit(cmd, map);
 
463
 
 
464
        ret = wait_event_interruptible_timeout(iwm->notif_queue,
 
465
                         ((notif = iwm_notif_find(iwm, cmd, source)) != NULL),
 
466
                                               timeout);
 
467
        clear_bit(cmd, map);
 
468
 
 
469
        if (!ret)
 
470
                return NULL;
 
471
 
 
472
        return notif;
 
473
}
 
474
 
 
475
int iwm_notif_handle(struct iwm_priv *iwm, u32 cmd, u8 source, long timeout)
 
476
{
 
477
        int ret;
 
478
        struct iwm_notif *notif;
 
479
 
 
480
        notif = iwm_notif_wait(iwm, cmd, source, timeout);
 
481
        if (!notif)
 
482
                return -ETIME;
 
483
 
 
484
        ret = iwm_rx_handle_resp(iwm, notif->buf, notif->buf_size, notif->cmd);
 
485
        kfree(notif->buf);
 
486
        kfree(notif);
 
487
 
 
488
        return ret;
 
489
}
 
490
 
 
491
static int iwm_config_boot_params(struct iwm_priv *iwm)
 
492
{
 
493
        struct iwm_udma_nonwifi_cmd target_cmd;
 
494
        int ret;
 
495
 
 
496
        /* check Wimax is off and config debug monitor */
 
497
        if (!modparam_wimax_enable) {
 
498
                u32 data1 = 0x1f;
 
499
                u32 addr1 = 0x606BE258;
 
500
 
 
501
                u32 data2_set = 0x0;
 
502
                u32 data2_clr = 0x1;
 
503
                u32 addr2 = 0x606BE100;
 
504
 
 
505
                u32 data3 = 0x1;
 
506
                u32 addr3 = 0x606BEC00;
 
507
 
 
508
                target_cmd.resp = 0;
 
509
                target_cmd.handle_by_hw = 0;
 
510
                target_cmd.eop = 1;
 
511
 
 
512
                target_cmd.opcode = UMAC_HDI_OUT_OPCODE_WRITE;
 
513
                target_cmd.addr = cpu_to_le32(addr1);
 
514
                target_cmd.op1_sz = cpu_to_le32(sizeof(u32));
 
515
                target_cmd.op2 = 0;
 
516
 
 
517
                ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data1);
 
518
                if (ret < 0) {
 
519
                        IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
 
520
                        return ret;
 
521
                }
 
522
 
 
523
                target_cmd.opcode = UMAC_HDI_OUT_OPCODE_READ_MODIFY_WRITE;
 
524
                target_cmd.addr = cpu_to_le32(addr2);
 
525
                target_cmd.op1_sz = cpu_to_le32(data2_set);
 
526
                target_cmd.op2 = cpu_to_le32(data2_clr);
 
527
 
 
528
                ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data1);
 
529
                if (ret < 0) {
 
530
                        IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
 
531
                        return ret;
 
532
                }
 
533
 
 
534
                target_cmd.opcode = UMAC_HDI_OUT_OPCODE_WRITE;
 
535
                target_cmd.addr = cpu_to_le32(addr3);
 
536
                target_cmd.op1_sz = cpu_to_le32(sizeof(u32));
 
537
                target_cmd.op2 = 0;
 
538
 
 
539
                ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data3);
 
540
                if (ret < 0) {
 
541
                        IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
 
542
                        return ret;
 
543
                }
 
544
        }
 
545
 
 
546
        return 0;
 
547
}
 
548
 
 
549
void iwm_init_default_profile(struct iwm_priv *iwm,
 
550
                              struct iwm_umac_profile *profile)
 
551
{
 
552
        memset(profile, 0, sizeof(struct iwm_umac_profile));
 
553
 
 
554
        profile->sec.auth_type = UMAC_AUTH_TYPE_OPEN;
 
555
        profile->sec.flags = UMAC_SEC_FLG_LEGACY_PROFILE;
 
556
        profile->sec.ucast_cipher = UMAC_CIPHER_TYPE_NONE;
 
557
        profile->sec.mcast_cipher = UMAC_CIPHER_TYPE_NONE;
 
558
 
 
559
        if (iwm->conf.enable_qos)
 
560
                profile->flags |= cpu_to_le16(UMAC_PROFILE_QOS_ALLOWED);
 
561
 
 
562
        profile->wireless_mode = iwm->conf.wireless_mode;
 
563
        profile->mode = cpu_to_le32(iwm->conf.mode);
 
564
 
 
565
        profile->ibss.atim = 0;
 
566
        profile->ibss.beacon_interval = 100;
 
567
        profile->ibss.join_only = 0;
 
568
        profile->ibss.band = iwm->conf.ibss_band;
 
569
        profile->ibss.channel = iwm->conf.ibss_channel;
 
570
}
 
571
 
 
572
void iwm_link_on(struct iwm_priv *iwm)
 
573
{
 
574
        netif_carrier_on(iwm_to_ndev(iwm));
 
575
        netif_tx_wake_all_queues(iwm_to_ndev(iwm));
 
576
 
 
577
        iwm_send_umac_stats_req(iwm, 0);
 
578
}
 
579
 
 
580
void iwm_link_off(struct iwm_priv *iwm)
 
581
{
 
582
        struct iw_statistics *wstats = &iwm->wstats;
 
583
        int i;
 
584
 
 
585
        netif_tx_stop_all_queues(iwm_to_ndev(iwm));
 
586
        netif_carrier_off(iwm_to_ndev(iwm));
 
587
 
 
588
        for (i = 0; i < IWM_TX_QUEUES; i++) {
 
589
                skb_queue_purge(&iwm->txq[i].queue);
 
590
                skb_queue_purge(&iwm->txq[i].stopped_queue);
 
591
 
 
592
                iwm->txq[i].concat_count = 0;
 
593
                iwm->txq[i].concat_ptr = iwm->txq[i].concat_buf;
 
594
 
 
595
                flush_workqueue(iwm->txq[i].wq);
 
596
        }
 
597
 
 
598
        iwm_rx_free(iwm);
 
599
 
 
600
        cancel_delayed_work_sync(&iwm->stats_request);
 
601
        memset(wstats, 0, sizeof(struct iw_statistics));
 
602
        wstats->qual.updated = IW_QUAL_ALL_INVALID;
 
603
 
 
604
        kfree(iwm->req_ie);
 
605
        iwm->req_ie = NULL;
 
606
        iwm->req_ie_len = 0;
 
607
        kfree(iwm->resp_ie);
 
608
        iwm->resp_ie = NULL;
 
609
        iwm->resp_ie_len = 0;
 
610
 
 
611
        del_timer_sync(&iwm->watchdog);
 
612
}
 
613
 
 
614
static void iwm_bss_list_clean(struct iwm_priv *iwm)
 
615
{
 
616
        struct iwm_bss_info *bss, *next;
 
617
 
 
618
        list_for_each_entry_safe(bss, next, &iwm->bss_list, node) {
 
619
                list_del(&bss->node);
 
620
                kfree(bss->bss);
 
621
                kfree(bss);
 
622
        }
 
623
}
 
624
 
 
625
static int iwm_channels_init(struct iwm_priv *iwm)
 
626
{
 
627
        int ret;
 
628
 
 
629
        ret = iwm_send_umac_channel_list(iwm);
 
630
        if (ret) {
 
631
                IWM_ERR(iwm, "Send channel list failed\n");
 
632
                return ret;
 
633
        }
 
634
 
 
635
        ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_GET_CHAN_INFO_LIST,
 
636
                               IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 
637
        if (ret) {
 
638
                IWM_ERR(iwm, "Didn't get a channel list notification\n");
 
639
                return ret;
 
640
        }
 
641
 
 
642
        return 0;
 
643
}
 
644
 
 
645
static int __iwm_up(struct iwm_priv *iwm)
 
646
{
 
647
        int ret;
 
648
        struct iwm_notif *notif_reboot, *notif_ack = NULL;
 
649
        struct wiphy *wiphy = iwm_to_wiphy(iwm);
 
650
        u32 wireless_mode;
 
651
 
 
652
        ret = iwm_bus_enable(iwm);
 
653
        if (ret) {
 
654
                IWM_ERR(iwm, "Couldn't enable function\n");
 
655
                return ret;
 
656
        }
 
657
 
 
658
        iwm_rx_setup_handlers(iwm);
 
659
 
 
660
        /* Wait for initial BARKER_REBOOT from hardware */
 
661
        notif_reboot = iwm_notif_wait(iwm, IWM_BARKER_REBOOT_NOTIFICATION,
 
662
                                      IWM_SRC_UDMA, 2 * HZ);
 
663
        if (!notif_reboot) {
 
664
                IWM_ERR(iwm, "Wait for REBOOT_BARKER timeout\n");
 
665
                goto err_disable;
 
666
        }
 
667
 
 
668
        /* We send the barker back */
 
669
        ret = iwm_bus_send_chunk(iwm, notif_reboot->buf, 16);
 
670
        if (ret) {
 
671
                IWM_ERR(iwm, "REBOOT barker response failed\n");
 
672
                kfree(notif_reboot);
 
673
                goto err_disable;
 
674
        }
 
675
 
 
676
        kfree(notif_reboot->buf);
 
677
        kfree(notif_reboot);
 
678
 
 
679
        /* Wait for ACK_BARKER from hardware */
 
680
        notif_ack = iwm_notif_wait(iwm, IWM_ACK_BARKER_NOTIFICATION,
 
681
                                   IWM_SRC_UDMA, 2 * HZ);
 
682
        if (!notif_ack) {
 
683
                IWM_ERR(iwm, "Wait for ACK_BARKER timeout\n");
 
684
                goto err_disable;
 
685
        }
 
686
 
 
687
        kfree(notif_ack->buf);
 
688
        kfree(notif_ack);
 
689
 
 
690
        /* We start to config static boot parameters */
 
691
        ret = iwm_config_boot_params(iwm);
 
692
        if (ret) {
 
693
                IWM_ERR(iwm, "Config boot parameters failed\n");
 
694
                goto err_disable;
 
695
        }
 
696
 
 
697
        ret = iwm_read_mac(iwm, iwm_to_ndev(iwm)->dev_addr);
 
698
        if (ret) {
 
699
                IWM_ERR(iwm, "MAC reading failed\n");
 
700
                goto err_disable;
 
701
        }
 
702
        memcpy(iwm_to_ndev(iwm)->perm_addr, iwm_to_ndev(iwm)->dev_addr,
 
703
                ETH_ALEN);
 
704
 
 
705
        /* We can load the FWs */
 
706
        ret = iwm_load_fw(iwm);
 
707
        if (ret) {
 
708
                IWM_ERR(iwm, "FW loading failed\n");
 
709
                goto err_disable;
 
710
        }
 
711
 
 
712
        ret = iwm_eeprom_fat_channels(iwm);
 
713
        if (ret) {
 
714
                IWM_ERR(iwm, "Couldnt read HT channels EEPROM entries\n");
 
715
                goto err_fw;
 
716
        }
 
717
 
 
718
        /*
 
719
         * Read our SKU capabilities.
 
720
         * If it's valid, we AND the configured wireless mode with the
 
721
         * device EEPROM value as the current profile wireless mode.
 
722
         */
 
723
        wireless_mode = iwm_eeprom_wireless_mode(iwm);
 
724
        if (wireless_mode) {
 
725
                iwm->conf.wireless_mode &= wireless_mode;
 
726
                if (iwm->umac_profile)
 
727
                        iwm->umac_profile->wireless_mode =
 
728
                                        iwm->conf.wireless_mode;
 
729
        } else
 
730
                IWM_ERR(iwm, "Wrong SKU capabilities: 0x%x\n",
 
731
                        *((u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_SKU_CAP)));
 
732
 
 
733
        snprintf(wiphy->fw_version, sizeof(wiphy->fw_version), "L%s_U%s",
 
734
                 iwm->lmac_version, iwm->umac_version);
 
735
 
 
736
        /* We configure the UMAC and enable the wifi module */
 
737
        ret = iwm_send_umac_config(iwm,
 
738
                        cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_CORE_EN) |
 
739
                        cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_LINK_EN) |
 
740
                        cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_MLME_EN));
 
741
        if (ret) {
 
742
                IWM_ERR(iwm, "UMAC config failed\n");
 
743
                goto err_fw;
 
744
        }
 
745
 
 
746
        ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS,
 
747
                               IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 
748
        if (ret) {
 
749
                IWM_ERR(iwm, "Didn't get a wifi core status notification\n");
 
750
                goto err_fw;
 
751
        }
 
752
 
 
753
        if (iwm->core_enabled != (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN |
 
754
                                  UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN)) {
 
755
                IWM_DBG_BOOT(iwm, DBG, "Not all cores enabled:0x%x\n",
 
756
                             iwm->core_enabled);
 
757
                ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS,
 
758
                               IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 
759
                if (ret) {
 
760
                        IWM_ERR(iwm, "Didn't get a core status notification\n");
 
761
                        goto err_fw;
 
762
                }
 
763
 
 
764
                if (iwm->core_enabled != (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN |
 
765
                                          UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN)) {
 
766
                        IWM_ERR(iwm, "Not all cores enabled: 0x%x\n",
 
767
                                iwm->core_enabled);
 
768
                        goto err_fw;
 
769
                } else {
 
770
                        IWM_INFO(iwm, "All cores enabled\n");
 
771
                }
 
772
        }
 
773
 
 
774
        ret = iwm_channels_init(iwm);
 
775
        if (ret < 0) {
 
776
                IWM_ERR(iwm, "Couldn't init channels\n");
 
777
                goto err_fw;
 
778
        }
 
779
 
 
780
        /* Set the READY bit to indicate interface is brought up successfully */
 
781
        set_bit(IWM_STATUS_READY, &iwm->status);
 
782
 
 
783
        return 0;
 
784
 
 
785
 err_fw:
 
786
        iwm_eeprom_exit(iwm);
 
787
 
 
788
 err_disable:
 
789
        ret = iwm_bus_disable(iwm);
 
790
        if (ret < 0)
 
791
                IWM_ERR(iwm, "Couldn't disable function\n");
 
792
 
 
793
        return -EIO;
 
794
}
 
795
 
 
796
int iwm_up(struct iwm_priv *iwm)
 
797
{
 
798
        int ret;
 
799
 
 
800
        mutex_lock(&iwm->mutex);
 
801
        ret = __iwm_up(iwm);
 
802
        mutex_unlock(&iwm->mutex);
 
803
 
 
804
        return ret;
 
805
}
 
806
 
 
807
static int __iwm_down(struct iwm_priv *iwm)
 
808
{
 
809
        int ret;
 
810
 
 
811
        /* The interface is already down */
 
812
        if (!test_bit(IWM_STATUS_READY, &iwm->status))
 
813
                return 0;
 
814
 
 
815
        if (iwm->scan_request) {
 
816
                cfg80211_scan_done(iwm->scan_request, true);
 
817
                iwm->scan_request = NULL;
 
818
        }
 
819
 
 
820
        clear_bit(IWM_STATUS_READY, &iwm->status);
 
821
 
 
822
        iwm_eeprom_exit(iwm);
 
823
        iwm_bss_list_clean(iwm);
 
824
        iwm_init_default_profile(iwm, iwm->umac_profile);
 
825
        iwm->umac_profile_active = false;
 
826
        iwm->default_key = -1;
 
827
        iwm->core_enabled = 0;
 
828
 
 
829
        ret = iwm_bus_disable(iwm);
 
830
        if (ret < 0) {
 
831
                IWM_ERR(iwm, "Couldn't disable function\n");
 
832
                return ret;
 
833
        }
 
834
 
 
835
        return 0;
 
836
}
 
837
 
 
838
int iwm_down(struct iwm_priv *iwm)
 
839
{
 
840
        int ret;
 
841
 
 
842
        mutex_lock(&iwm->mutex);
 
843
        ret = __iwm_down(iwm);
 
844
        mutex_unlock(&iwm->mutex);
 
845
 
 
846
        return ret;
 
847
}