1 /******************************************************************************
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
8 * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved.
9 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of version 2 of the GNU General Public License as
13 * published by the Free Software Foundation.
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
25 * The full GNU General Public License is included in this distribution
26 * in the file called COPYING.
28 * Contact Information:
29 * Intel Linux Wireless <ilw@linux.intel.com>
30 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
34 * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
35 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
36 * All rights reserved.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
42 * * Redistributions of source code must retain the above copyright
43 * notice, this list of conditions and the following disclaimer.
44 * * Redistributions in binary form must reproduce the above copyright
45 * notice, this list of conditions and the following disclaimer in
46 * the documentation and/or other materials provided with the
48 * * Neither the name Intel Corporation nor the names of its
49 * contributors may be used to endorse or promote products derived
50 * from this software without specific prior written permission.
52 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
53 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
54 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
55 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
56 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
57 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
58 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
59 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
60 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
61 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
62 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64 *****************************************************************************/
65 #include <linux/completion.h>
66 #include <linux/dma-mapping.h>
67 #include <linux/firmware.h>
68 #include <linux/module.h>
69 #include <linux/vmalloc.h>
72 #include "iwl-debug.h"
73 #include "iwl-trans.h"
74 #include "iwl-op-mode.h"
75 #include "iwl-agn-hw.h"
77 #include "iwl-config.h"
78 #include "iwl-modparams.h"
80 /* private includes */
81 #include "iwl-fw-file.h"
83 /******************************************************************************
87 ******************************************************************************/
90 * module name, copyright, version, etc.
92 #define DRV_DESCRIPTION "Intel(R) Wireless WiFi driver for Linux"
94 #ifdef CONFIG_IWLWIFI_DEBUG
100 #define DRV_VERSION IWLWIFI_VERSION VD
102 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
103 MODULE_VERSION(DRV_VERSION
);
104 MODULE_AUTHOR(DRV_COPYRIGHT
" " DRV_AUTHOR
);
105 MODULE_LICENSE("GPL");
107 #ifdef CONFIG_IWLWIFI_DEBUGFS
108 static struct dentry
*iwl_dbgfs_root
;
112 * struct iwl_drv - drv common data
113 * @list: list of drv structures using this opmode
114 * @fw: the iwl_fw structure
115 * @op_mode: the running op_mode
116 * @trans: transport layer
117 * @dev: for debug prints only
118 * @cfg: configuration struct
119 * @fw_index: firmware revision to try loading
120 * @firmware_name: composite filename of ucode file to load
121 * @request_firmware_complete: the firmware has been obtained from user space
124 struct list_head list
;
127 struct iwl_op_mode
*op_mode
;
128 struct iwl_trans
*trans
;
130 const struct iwl_cfg
*cfg
;
132 int fw_index
; /* firmware we're trying to load */
133 char firmware_name
[32]; /* name of firmware file to load */
135 struct completion request_firmware_complete
;
137 #ifdef CONFIG_IWLWIFI_DEBUGFS
138 struct dentry
*dbgfs_drv
;
139 struct dentry
*dbgfs_trans
;
140 struct dentry
*dbgfs_op_mode
;
149 /* Protects the table contents, i.e. the ops pointer & drv list */
150 static struct mutex iwlwifi_opmode_table_mtx
;
151 static struct iwlwifi_opmode_table
{
152 const char *name
; /* name: iwldvm, iwlmvm, etc */
153 const struct iwl_op_mode_ops
*ops
; /* pointer to op_mode ops */
154 struct list_head drv
; /* list of devices using this op_mode */
155 } iwlwifi_opmode_table
[] = { /* ops set when driver is initialized */
156 [DVM_OP_MODE
] = { .name
= "iwldvm", .ops
= NULL
},
157 [MVM_OP_MODE
] = { .name
= "iwlmvm", .ops
= NULL
},
160 #define IWL_DEFAULT_SCAN_CHANNELS 40
163 * struct fw_sec: Just for the image parsing proccess.
164 * For the fw storage we are using struct fw_desc.
167 const void *data
; /* the sec data */
168 size_t size
; /* section size */
169 u32 offset
; /* offset of writing in the device */
172 static void iwl_free_fw_desc(struct iwl_drv
*drv
, struct fw_desc
*desc
)
179 static void iwl_free_fw_img(struct iwl_drv
*drv
, struct fw_img
*img
)
182 for (i
= 0; i
< IWL_UCODE_SECTION_MAX
; i
++)
183 iwl_free_fw_desc(drv
, &img
->sec
[i
]);
186 static void iwl_dealloc_ucode(struct iwl_drv
*drv
)
189 for (i
= 0; i
< IWL_UCODE_TYPE_MAX
; i
++)
190 iwl_free_fw_img(drv
, drv
->fw
.img
+ i
);
193 static int iwl_alloc_fw_desc(struct iwl_drv
*drv
, struct fw_desc
*desc
,
200 if (!sec
|| !sec
->size
)
203 data
= vmalloc(sec
->size
);
207 desc
->len
= sec
->size
;
208 desc
->offset
= sec
->offset
;
209 memcpy(data
, sec
->data
, desc
->len
);
215 static void iwl_req_fw_callback(const struct firmware
*ucode_raw
,
218 #define UCODE_EXPERIMENTAL_INDEX 100
219 #define UCODE_EXPERIMENTAL_TAG "exp"
221 static int iwl_request_firmware(struct iwl_drv
*drv
, bool first
)
223 const char *name_pre
= drv
->cfg
->fw_name_pre
;
227 #ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
228 drv
->fw_index
= UCODE_EXPERIMENTAL_INDEX
;
229 strcpy(tag
, UCODE_EXPERIMENTAL_TAG
);
230 } else if (drv
->fw_index
== UCODE_EXPERIMENTAL_INDEX
) {
232 drv
->fw_index
= drv
->cfg
->ucode_api_max
;
233 sprintf(tag
, "%d", drv
->fw_index
);
236 sprintf(tag
, "%d", drv
->fw_index
);
239 if (drv
->fw_index
< drv
->cfg
->ucode_api_min
) {
240 IWL_ERR(drv
, "no suitable firmware found!\n");
244 snprintf(drv
->firmware_name
, sizeof(drv
->firmware_name
), "%s%s.ucode",
247 IWL_DEBUG_INFO(drv
, "attempting to load firmware %s'%s'\n",
248 (drv
->fw_index
== UCODE_EXPERIMENTAL_INDEX
)
249 ? "EXPERIMENTAL " : "",
252 return request_firmware_nowait(THIS_MODULE
, 1, drv
->firmware_name
,
254 GFP_KERNEL
, drv
, iwl_req_fw_callback
);
257 struct fw_img_parsing
{
258 struct fw_sec sec
[IWL_UCODE_SECTION_MAX
];
263 * struct fw_sec_parsing: to extract fw section and it's offset from tlv
265 struct fw_sec_parsing
{
271 * struct iwl_tlv_calib_data - parse the default calib data from TLV
273 * @ucode_type: the uCode to which the following default calib relates.
274 * @calib: default calibrations.
276 struct iwl_tlv_calib_data
{
278 struct iwl_tlv_calib_ctrl calib
;
281 struct iwl_firmware_pieces
{
282 struct fw_img_parsing img
[IWL_UCODE_TYPE_MAX
];
284 u32 init_evtlog_ptr
, init_evtlog_size
, init_errlog_ptr
;
285 u32 inst_evtlog_ptr
, inst_evtlog_size
, inst_errlog_ptr
;
289 * These functions are just to extract uCode section data from the pieces
292 static struct fw_sec
*get_sec(struct iwl_firmware_pieces
*pieces
,
293 enum iwl_ucode_type type
,
296 return &pieces
->img
[type
].sec
[sec
];
299 static void set_sec_data(struct iwl_firmware_pieces
*pieces
,
300 enum iwl_ucode_type type
,
304 pieces
->img
[type
].sec
[sec
].data
= data
;
307 static void set_sec_size(struct iwl_firmware_pieces
*pieces
,
308 enum iwl_ucode_type type
,
312 pieces
->img
[type
].sec
[sec
].size
= size
;
315 static size_t get_sec_size(struct iwl_firmware_pieces
*pieces
,
316 enum iwl_ucode_type type
,
319 return pieces
->img
[type
].sec
[sec
].size
;
322 static void set_sec_offset(struct iwl_firmware_pieces
*pieces
,
323 enum iwl_ucode_type type
,
327 pieces
->img
[type
].sec
[sec
].offset
= offset
;
330 static int iwl_store_cscheme(struct iwl_fw
*fw
, const u8
*data
, const u32 len
)
333 struct iwl_fw_cscheme_list
*l
= (struct iwl_fw_cscheme_list
*)data
;
334 struct iwl_fw_cipher_scheme
*fwcs
;
335 struct ieee80211_cipher_scheme
*cs
;
338 if (len
< sizeof(*l
) ||
339 len
< sizeof(l
->size
) + l
->size
* sizeof(l
->cs
[0]))
342 for (i
= 0, j
= 0; i
< IWL_UCODE_MAX_CS
&& i
< l
->size
; i
++) {
344 cipher
= le32_to_cpu(fwcs
->cipher
);
346 /* we skip schemes with zero cipher suite selector */
352 cs
->iftype
= BIT(NL80211_IFTYPE_STATION
);
353 cs
->hdr_len
= fwcs
->hdr_len
;
354 cs
->pn_len
= fwcs
->pn_len
;
355 cs
->pn_off
= fwcs
->pn_off
;
356 cs
->key_idx_off
= fwcs
->key_idx_off
;
357 cs
->key_idx_mask
= fwcs
->key_idx_mask
;
358 cs
->key_idx_shift
= fwcs
->key_idx_shift
;
359 cs
->mic_len
= fwcs
->mic_len
;
366 * Gets uCode section from tlv.
368 static int iwl_store_ucode_sec(struct iwl_firmware_pieces
*pieces
,
369 const void *data
, enum iwl_ucode_type type
,
372 struct fw_img_parsing
*img
;
374 struct fw_sec_parsing
*sec_parse
;
376 if (WARN_ON(!pieces
|| !data
|| type
>= IWL_UCODE_TYPE_MAX
))
379 sec_parse
= (struct fw_sec_parsing
*)data
;
381 img
= &pieces
->img
[type
];
382 sec
= &img
->sec
[img
->sec_counter
];
384 sec
->offset
= le32_to_cpu(sec_parse
->offset
);
385 sec
->data
= sec_parse
->data
;
386 sec
->size
= size
- sizeof(sec_parse
->offset
);
393 static int iwl_set_default_calib(struct iwl_drv
*drv
, const u8
*data
)
395 struct iwl_tlv_calib_data
*def_calib
=
396 (struct iwl_tlv_calib_data
*)data
;
397 u32 ucode_type
= le32_to_cpu(def_calib
->ucode_type
);
398 if (ucode_type
>= IWL_UCODE_TYPE_MAX
) {
399 IWL_ERR(drv
, "Wrong ucode_type %u for default calibration.\n",
403 drv
->fw
.default_calib
[ucode_type
].flow_trigger
=
404 def_calib
->calib
.flow_trigger
;
405 drv
->fw
.default_calib
[ucode_type
].event_trigger
=
406 def_calib
->calib
.event_trigger
;
411 static int iwl_set_ucode_api_flags(struct iwl_drv
*drv
, const u8
*data
,
412 struct iwl_ucode_capabilities
*capa
)
414 const struct iwl_ucode_api
*ucode_api
= (void *)data
;
415 u32 api_index
= le32_to_cpu(ucode_api
->api_index
);
417 if (api_index
>= IWL_API_ARRAY_SIZE
) {
418 IWL_ERR(drv
, "api_index larger than supported by driver\n");
422 capa
->api
[api_index
] = le32_to_cpu(ucode_api
->api_flags
);
427 static int iwl_set_ucode_capabilities(struct iwl_drv
*drv
, const u8
*data
,
428 struct iwl_ucode_capabilities
*capa
)
430 const struct iwl_ucode_capa
*ucode_capa
= (void *)data
;
431 u32 api_index
= le32_to_cpu(ucode_capa
->api_index
);
433 if (api_index
>= IWL_CAPABILITIES_ARRAY_SIZE
) {
434 IWL_ERR(drv
, "api_index larger than supported by driver\n");
438 capa
->capa
[api_index
] = le32_to_cpu(ucode_capa
->api_capa
);
443 static int iwl_parse_v1_v2_firmware(struct iwl_drv
*drv
,
444 const struct firmware
*ucode_raw
,
445 struct iwl_firmware_pieces
*pieces
)
447 struct iwl_ucode_header
*ucode
= (void *)ucode_raw
->data
;
448 u32 api_ver
, hdr_size
, build
;
452 drv
->fw
.ucode_ver
= le32_to_cpu(ucode
->ver
);
453 api_ver
= IWL_UCODE_API(drv
->fw
.ucode_ver
);
458 if (ucode_raw
->size
< hdr_size
) {
459 IWL_ERR(drv
, "File size too small!\n");
462 build
= le32_to_cpu(ucode
->u
.v2
.build
);
463 set_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_INST
,
464 le32_to_cpu(ucode
->u
.v2
.inst_size
));
465 set_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_DATA
,
466 le32_to_cpu(ucode
->u
.v2
.data_size
));
467 set_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
,
468 le32_to_cpu(ucode
->u
.v2
.init_size
));
469 set_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
,
470 le32_to_cpu(ucode
->u
.v2
.init_data_size
));
471 src
= ucode
->u
.v2
.data
;
477 if (ucode_raw
->size
< hdr_size
) {
478 IWL_ERR(drv
, "File size too small!\n");
482 set_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_INST
,
483 le32_to_cpu(ucode
->u
.v1
.inst_size
));
484 set_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_DATA
,
485 le32_to_cpu(ucode
->u
.v1
.data_size
));
486 set_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
,
487 le32_to_cpu(ucode
->u
.v1
.init_size
));
488 set_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
,
489 le32_to_cpu(ucode
->u
.v1
.init_data_size
));
490 src
= ucode
->u
.v1
.data
;
495 sprintf(buildstr
, " build %u%s", build
,
496 (drv
->fw_index
== UCODE_EXPERIMENTAL_INDEX
)
501 snprintf(drv
->fw
.fw_version
,
502 sizeof(drv
->fw
.fw_version
),
504 IWL_UCODE_MAJOR(drv
->fw
.ucode_ver
),
505 IWL_UCODE_MINOR(drv
->fw
.ucode_ver
),
506 IWL_UCODE_API(drv
->fw
.ucode_ver
),
507 IWL_UCODE_SERIAL(drv
->fw
.ucode_ver
),
510 /* Verify size of file vs. image size info in file's header */
512 if (ucode_raw
->size
!= hdr_size
+
513 get_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_INST
) +
514 get_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_DATA
) +
515 get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
) +
516 get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
)) {
519 "uCode file size %d does not match expected size\n",
520 (int)ucode_raw
->size
);
525 set_sec_data(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_INST
, src
);
526 src
+= get_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_INST
);
527 set_sec_offset(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_INST
,
528 IWLAGN_RTC_INST_LOWER_BOUND
);
529 set_sec_data(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_DATA
, src
);
530 src
+= get_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_DATA
);
531 set_sec_offset(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_DATA
,
532 IWLAGN_RTC_DATA_LOWER_BOUND
);
533 set_sec_data(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
, src
);
534 src
+= get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
);
535 set_sec_offset(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
,
536 IWLAGN_RTC_INST_LOWER_BOUND
);
537 set_sec_data(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
, src
);
538 src
+= get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
);
539 set_sec_offset(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
,
540 IWLAGN_RTC_DATA_LOWER_BOUND
);
544 static int iwl_parse_tlv_firmware(struct iwl_drv
*drv
,
545 const struct firmware
*ucode_raw
,
546 struct iwl_firmware_pieces
*pieces
,
547 struct iwl_ucode_capabilities
*capa
)
549 struct iwl_tlv_ucode_header
*ucode
= (void *)ucode_raw
->data
;
550 struct iwl_ucode_tlv
*tlv
;
551 size_t len
= ucode_raw
->size
;
554 enum iwl_ucode_tlv_type tlv_type
;
560 if (len
< sizeof(*ucode
)) {
561 IWL_ERR(drv
, "uCode has invalid length: %zd\n", len
);
565 if (ucode
->magic
!= cpu_to_le32(IWL_TLV_UCODE_MAGIC
)) {
566 IWL_ERR(drv
, "invalid uCode magic: 0X%x\n",
567 le32_to_cpu(ucode
->magic
));
571 drv
->fw
.ucode_ver
= le32_to_cpu(ucode
->ver
);
572 memcpy(drv
->fw
.human_readable
, ucode
->human_readable
,
573 sizeof(drv
->fw
.human_readable
));
574 build
= le32_to_cpu(ucode
->build
);
577 sprintf(buildstr
, " build %u%s", build
,
578 (drv
->fw_index
== UCODE_EXPERIMENTAL_INDEX
)
583 snprintf(drv
->fw
.fw_version
,
584 sizeof(drv
->fw
.fw_version
),
586 IWL_UCODE_MAJOR(drv
->fw
.ucode_ver
),
587 IWL_UCODE_MINOR(drv
->fw
.ucode_ver
),
588 IWL_UCODE_API(drv
->fw
.ucode_ver
),
589 IWL_UCODE_SERIAL(drv
->fw
.ucode_ver
),
594 len
-= sizeof(*ucode
);
596 while (len
>= sizeof(*tlv
)) {
600 tlv_len
= le32_to_cpu(tlv
->length
);
601 tlv_type
= le32_to_cpu(tlv
->type
);
602 tlv_data
= tlv
->data
;
605 IWL_ERR(drv
, "invalid TLV len: %zd/%u\n",
609 len
-= ALIGN(tlv_len
, 4);
610 data
+= sizeof(*tlv
) + ALIGN(tlv_len
, 4);
613 case IWL_UCODE_TLV_INST
:
614 set_sec_data(pieces
, IWL_UCODE_REGULAR
,
615 IWL_UCODE_SECTION_INST
, tlv_data
);
616 set_sec_size(pieces
, IWL_UCODE_REGULAR
,
617 IWL_UCODE_SECTION_INST
, tlv_len
);
618 set_sec_offset(pieces
, IWL_UCODE_REGULAR
,
619 IWL_UCODE_SECTION_INST
,
620 IWLAGN_RTC_INST_LOWER_BOUND
);
622 case IWL_UCODE_TLV_DATA
:
623 set_sec_data(pieces
, IWL_UCODE_REGULAR
,
624 IWL_UCODE_SECTION_DATA
, tlv_data
);
625 set_sec_size(pieces
, IWL_UCODE_REGULAR
,
626 IWL_UCODE_SECTION_DATA
, tlv_len
);
627 set_sec_offset(pieces
, IWL_UCODE_REGULAR
,
628 IWL_UCODE_SECTION_DATA
,
629 IWLAGN_RTC_DATA_LOWER_BOUND
);
631 case IWL_UCODE_TLV_INIT
:
632 set_sec_data(pieces
, IWL_UCODE_INIT
,
633 IWL_UCODE_SECTION_INST
, tlv_data
);
634 set_sec_size(pieces
, IWL_UCODE_INIT
,
635 IWL_UCODE_SECTION_INST
, tlv_len
);
636 set_sec_offset(pieces
, IWL_UCODE_INIT
,
637 IWL_UCODE_SECTION_INST
,
638 IWLAGN_RTC_INST_LOWER_BOUND
);
640 case IWL_UCODE_TLV_INIT_DATA
:
641 set_sec_data(pieces
, IWL_UCODE_INIT
,
642 IWL_UCODE_SECTION_DATA
, tlv_data
);
643 set_sec_size(pieces
, IWL_UCODE_INIT
,
644 IWL_UCODE_SECTION_DATA
, tlv_len
);
645 set_sec_offset(pieces
, IWL_UCODE_INIT
,
646 IWL_UCODE_SECTION_DATA
,
647 IWLAGN_RTC_DATA_LOWER_BOUND
);
649 case IWL_UCODE_TLV_BOOT
:
650 IWL_ERR(drv
, "Found unexpected BOOT ucode\n");
652 case IWL_UCODE_TLV_PROBE_MAX_LEN
:
653 if (tlv_len
!= sizeof(u32
))
654 goto invalid_tlv_len
;
655 capa
->max_probe_length
=
656 le32_to_cpup((__le32
*)tlv_data
);
658 case IWL_UCODE_TLV_PAN
:
660 goto invalid_tlv_len
;
661 capa
->flags
|= IWL_UCODE_TLV_FLAGS_PAN
;
663 case IWL_UCODE_TLV_FLAGS
:
664 /* must be at least one u32 */
665 if (tlv_len
< sizeof(u32
))
666 goto invalid_tlv_len
;
667 /* and a proper number of u32s */
668 if (tlv_len
% sizeof(u32
))
669 goto invalid_tlv_len
;
671 * This driver only reads the first u32 as
672 * right now no more features are defined,
673 * if that changes then either the driver
674 * will not work with the new firmware, or
675 * it'll not take advantage of new features.
677 capa
->flags
= le32_to_cpup((__le32
*)tlv_data
);
679 case IWL_UCODE_TLV_API_CHANGES_SET
:
680 if (tlv_len
!= sizeof(struct iwl_ucode_api
))
681 goto invalid_tlv_len
;
682 if (iwl_set_ucode_api_flags(drv
, tlv_data
, capa
))
685 case IWL_UCODE_TLV_ENABLED_CAPABILITIES
:
686 if (tlv_len
!= sizeof(struct iwl_ucode_capa
))
687 goto invalid_tlv_len
;
688 if (iwl_set_ucode_capabilities(drv
, tlv_data
, capa
))
691 case IWL_UCODE_TLV_INIT_EVTLOG_PTR
:
692 if (tlv_len
!= sizeof(u32
))
693 goto invalid_tlv_len
;
694 pieces
->init_evtlog_ptr
=
695 le32_to_cpup((__le32
*)tlv_data
);
697 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE
:
698 if (tlv_len
!= sizeof(u32
))
699 goto invalid_tlv_len
;
700 pieces
->init_evtlog_size
=
701 le32_to_cpup((__le32
*)tlv_data
);
703 case IWL_UCODE_TLV_INIT_ERRLOG_PTR
:
704 if (tlv_len
!= sizeof(u32
))
705 goto invalid_tlv_len
;
706 pieces
->init_errlog_ptr
=
707 le32_to_cpup((__le32
*)tlv_data
);
709 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR
:
710 if (tlv_len
!= sizeof(u32
))
711 goto invalid_tlv_len
;
712 pieces
->inst_evtlog_ptr
=
713 le32_to_cpup((__le32
*)tlv_data
);
715 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE
:
716 if (tlv_len
!= sizeof(u32
))
717 goto invalid_tlv_len
;
718 pieces
->inst_evtlog_size
=
719 le32_to_cpup((__le32
*)tlv_data
);
721 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR
:
722 if (tlv_len
!= sizeof(u32
))
723 goto invalid_tlv_len
;
724 pieces
->inst_errlog_ptr
=
725 le32_to_cpup((__le32
*)tlv_data
);
727 case IWL_UCODE_TLV_ENHANCE_SENS_TBL
:
729 goto invalid_tlv_len
;
730 drv
->fw
.enhance_sensitivity_table
= true;
732 case IWL_UCODE_TLV_WOWLAN_INST
:
733 set_sec_data(pieces
, IWL_UCODE_WOWLAN
,
734 IWL_UCODE_SECTION_INST
, tlv_data
);
735 set_sec_size(pieces
, IWL_UCODE_WOWLAN
,
736 IWL_UCODE_SECTION_INST
, tlv_len
);
737 set_sec_offset(pieces
, IWL_UCODE_WOWLAN
,
738 IWL_UCODE_SECTION_INST
,
739 IWLAGN_RTC_INST_LOWER_BOUND
);
741 case IWL_UCODE_TLV_WOWLAN_DATA
:
742 set_sec_data(pieces
, IWL_UCODE_WOWLAN
,
743 IWL_UCODE_SECTION_DATA
, tlv_data
);
744 set_sec_size(pieces
, IWL_UCODE_WOWLAN
,
745 IWL_UCODE_SECTION_DATA
, tlv_len
);
746 set_sec_offset(pieces
, IWL_UCODE_WOWLAN
,
747 IWL_UCODE_SECTION_DATA
,
748 IWLAGN_RTC_DATA_LOWER_BOUND
);
750 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE
:
751 if (tlv_len
!= sizeof(u32
))
752 goto invalid_tlv_len
;
753 capa
->standard_phy_calibration_size
=
754 le32_to_cpup((__le32
*)tlv_data
);
756 case IWL_UCODE_TLV_SEC_RT
:
757 iwl_store_ucode_sec(pieces
, tlv_data
, IWL_UCODE_REGULAR
,
759 drv
->fw
.mvm_fw
= true;
761 case IWL_UCODE_TLV_SEC_INIT
:
762 iwl_store_ucode_sec(pieces
, tlv_data
, IWL_UCODE_INIT
,
764 drv
->fw
.mvm_fw
= true;
766 case IWL_UCODE_TLV_SEC_WOWLAN
:
767 iwl_store_ucode_sec(pieces
, tlv_data
, IWL_UCODE_WOWLAN
,
769 drv
->fw
.mvm_fw
= true;
771 case IWL_UCODE_TLV_DEF_CALIB
:
772 if (tlv_len
!= sizeof(struct iwl_tlv_calib_data
))
773 goto invalid_tlv_len
;
774 if (iwl_set_default_calib(drv
, tlv_data
))
777 case IWL_UCODE_TLV_PHY_SKU
:
778 if (tlv_len
!= sizeof(u32
))
779 goto invalid_tlv_len
;
780 drv
->fw
.phy_config
= le32_to_cpup((__le32
*)tlv_data
);
781 drv
->fw
.valid_tx_ant
= (drv
->fw
.phy_config
&
782 FW_PHY_CFG_TX_CHAIN
) >>
783 FW_PHY_CFG_TX_CHAIN_POS
;
784 drv
->fw
.valid_rx_ant
= (drv
->fw
.phy_config
&
785 FW_PHY_CFG_RX_CHAIN
) >>
786 FW_PHY_CFG_RX_CHAIN_POS
;
788 case IWL_UCODE_TLV_SECURE_SEC_RT
:
789 iwl_store_ucode_sec(pieces
, tlv_data
, IWL_UCODE_REGULAR
,
791 drv
->fw
.mvm_fw
= true;
792 drv
->fw
.img
[IWL_UCODE_REGULAR
].is_secure
= true;
794 case IWL_UCODE_TLV_SECURE_SEC_INIT
:
795 iwl_store_ucode_sec(pieces
, tlv_data
, IWL_UCODE_INIT
,
797 drv
->fw
.mvm_fw
= true;
798 drv
->fw
.img
[IWL_UCODE_INIT
].is_secure
= true;
800 case IWL_UCODE_TLV_SECURE_SEC_WOWLAN
:
801 iwl_store_ucode_sec(pieces
, tlv_data
, IWL_UCODE_WOWLAN
,
803 drv
->fw
.mvm_fw
= true;
804 drv
->fw
.img
[IWL_UCODE_WOWLAN
].is_secure
= true;
806 case IWL_UCODE_TLV_NUM_OF_CPU
:
807 if (tlv_len
!= sizeof(u32
))
808 goto invalid_tlv_len
;
810 le32_to_cpup((__le32
*)tlv_data
);
812 if (num_of_cpus
== 2) {
813 drv
->fw
.img
[IWL_UCODE_REGULAR
].is_dual_cpus
=
815 drv
->fw
.img
[IWL_UCODE_INIT
].is_dual_cpus
=
817 drv
->fw
.img
[IWL_UCODE_WOWLAN
].is_dual_cpus
=
819 } else if ((num_of_cpus
> 2) || (num_of_cpus
< 1)) {
820 IWL_ERR(drv
, "Driver support upto 2 CPUs\n");
824 case IWL_UCODE_TLV_CSCHEME
:
825 if (iwl_store_cscheme(&drv
->fw
, tlv_data
, tlv_len
))
826 goto invalid_tlv_len
;
828 case IWL_UCODE_TLV_N_SCAN_CHANNELS
:
829 if (tlv_len
!= sizeof(u32
))
830 goto invalid_tlv_len
;
831 capa
->n_scan_channels
=
832 le32_to_cpup((__le32
*)tlv_data
);
835 IWL_DEBUG_INFO(drv
, "unknown TLV: %d\n", tlv_type
);
841 IWL_ERR(drv
, "invalid TLV after parsing: %zd\n", len
);
842 iwl_print_hex_dump(drv
, IWL_DL_FW
, (u8
*)data
, len
);
849 IWL_ERR(drv
, "TLV %d has invalid size: %u\n", tlv_type
, tlv_len
);
851 iwl_print_hex_dump(drv
, IWL_DL_FW
, tlv_data
, tlv_len
);
856 static int iwl_alloc_ucode(struct iwl_drv
*drv
,
857 struct iwl_firmware_pieces
*pieces
,
858 enum iwl_ucode_type type
)
862 i
< IWL_UCODE_SECTION_MAX
&& get_sec_size(pieces
, type
, i
);
864 if (iwl_alloc_fw_desc(drv
, &(drv
->fw
.img
[type
].sec
[i
]),
865 get_sec(pieces
, type
, i
)))
870 static int validate_sec_sizes(struct iwl_drv
*drv
,
871 struct iwl_firmware_pieces
*pieces
,
872 const struct iwl_cfg
*cfg
)
874 IWL_DEBUG_INFO(drv
, "f/w package hdr runtime inst size = %Zd\n",
875 get_sec_size(pieces
, IWL_UCODE_REGULAR
,
876 IWL_UCODE_SECTION_INST
));
877 IWL_DEBUG_INFO(drv
, "f/w package hdr runtime data size = %Zd\n",
878 get_sec_size(pieces
, IWL_UCODE_REGULAR
,
879 IWL_UCODE_SECTION_DATA
));
880 IWL_DEBUG_INFO(drv
, "f/w package hdr init inst size = %Zd\n",
881 get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
));
882 IWL_DEBUG_INFO(drv
, "f/w package hdr init data size = %Zd\n",
883 get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
));
885 /* Verify that uCode images will fit in card's SRAM. */
886 if (get_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_INST
) >
887 cfg
->max_inst_size
) {
888 IWL_ERR(drv
, "uCode instr len %Zd too large to fit in\n",
889 get_sec_size(pieces
, IWL_UCODE_REGULAR
,
890 IWL_UCODE_SECTION_INST
));
894 if (get_sec_size(pieces
, IWL_UCODE_REGULAR
, IWL_UCODE_SECTION_DATA
) >
895 cfg
->max_data_size
) {
896 IWL_ERR(drv
, "uCode data len %Zd too large to fit in\n",
897 get_sec_size(pieces
, IWL_UCODE_REGULAR
,
898 IWL_UCODE_SECTION_DATA
));
902 if (get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_INST
) >
903 cfg
->max_inst_size
) {
904 IWL_ERR(drv
, "uCode init instr len %Zd too large to fit in\n",
905 get_sec_size(pieces
, IWL_UCODE_INIT
,
906 IWL_UCODE_SECTION_INST
));
910 if (get_sec_size(pieces
, IWL_UCODE_INIT
, IWL_UCODE_SECTION_DATA
) >
911 cfg
->max_data_size
) {
912 IWL_ERR(drv
, "uCode init data len %Zd too large to fit in\n",
913 get_sec_size(pieces
, IWL_UCODE_REGULAR
,
914 IWL_UCODE_SECTION_DATA
));
920 static struct iwl_op_mode
*
921 _iwl_op_mode_start(struct iwl_drv
*drv
, struct iwlwifi_opmode_table
*op
)
923 const struct iwl_op_mode_ops
*ops
= op
->ops
;
924 struct dentry
*dbgfs_dir
= NULL
;
925 struct iwl_op_mode
*op_mode
= NULL
;
927 #ifdef CONFIG_IWLWIFI_DEBUGFS
928 drv
->dbgfs_op_mode
= debugfs_create_dir(op
->name
,
930 if (!drv
->dbgfs_op_mode
) {
932 "failed to create opmode debugfs directory\n");
935 dbgfs_dir
= drv
->dbgfs_op_mode
;
938 op_mode
= ops
->start(drv
->trans
, drv
->cfg
, &drv
->fw
, dbgfs_dir
);
940 #ifdef CONFIG_IWLWIFI_DEBUGFS
942 debugfs_remove_recursive(drv
->dbgfs_op_mode
);
943 drv
->dbgfs_op_mode
= NULL
;
950 static void _iwl_op_mode_stop(struct iwl_drv
*drv
)
952 /* op_mode can be NULL if its start failed */
954 iwl_op_mode_stop(drv
->op_mode
);
957 #ifdef CONFIG_IWLWIFI_DEBUGFS
958 debugfs_remove_recursive(drv
->dbgfs_op_mode
);
959 drv
->dbgfs_op_mode
= NULL
;
965 * iwl_req_fw_callback - callback when firmware was loaded
967 * If loaded successfully, copies the firmware into buffers
968 * for the card to fetch (via DMA).
970 static void iwl_req_fw_callback(const struct firmware
*ucode_raw
, void *context
)
972 struct iwl_drv
*drv
= context
;
973 struct iwl_fw
*fw
= &drv
->fw
;
974 struct iwl_ucode_header
*ucode
;
975 struct iwlwifi_opmode_table
*op
;
977 struct iwl_firmware_pieces pieces
;
978 const unsigned int api_max
= drv
->cfg
->ucode_api_max
;
979 unsigned int api_ok
= drv
->cfg
->ucode_api_ok
;
980 const unsigned int api_min
= drv
->cfg
->ucode_api_min
;
983 bool load_module
= false;
985 fw
->ucode_capa
.max_probe_length
= IWL_DEFAULT_MAX_PROBE_LENGTH
;
986 fw
->ucode_capa
.standard_phy_calibration_size
=
987 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE
;
988 fw
->ucode_capa
.n_scan_channels
= IWL_DEFAULT_SCAN_CHANNELS
;
993 memset(&pieces
, 0, sizeof(pieces
));
996 if (drv
->fw_index
<= api_ok
)
998 "request for firmware file '%s' failed.\n",
1003 IWL_DEBUG_INFO(drv
, "Loaded firmware file '%s' (%zd bytes).\n",
1004 drv
->firmware_name
, ucode_raw
->size
);
1006 /* Make sure that we got at least the API version number */
1007 if (ucode_raw
->size
< 4) {
1008 IWL_ERR(drv
, "File size way too small!\n");
1012 /* Data from ucode file: header followed by uCode images */
1013 ucode
= (struct iwl_ucode_header
*)ucode_raw
->data
;
1016 err
= iwl_parse_v1_v2_firmware(drv
, ucode_raw
, &pieces
);
1018 err
= iwl_parse_tlv_firmware(drv
, ucode_raw
, &pieces
,
1024 api_ver
= IWL_UCODE_API(drv
->fw
.ucode_ver
);
1027 * api_ver should match the api version forming part of the
1028 * firmware filename ... but we don't check for that and only rely
1029 * on the API version read from firmware header from here on forward
1031 /* no api version check required for experimental uCode */
1032 if (drv
->fw_index
!= UCODE_EXPERIMENTAL_INDEX
) {
1033 if (api_ver
< api_min
|| api_ver
> api_max
) {
1035 "Driver unable to support your firmware API. "
1036 "Driver supports v%u, firmware is v%u.\n",
1041 if (api_ver
< api_ok
) {
1042 if (api_ok
!= api_max
)
1043 IWL_ERR(drv
, "Firmware has old API version, "
1044 "expected v%u through v%u, got v%u.\n",
1045 api_ok
, api_max
, api_ver
);
1047 IWL_ERR(drv
, "Firmware has old API version, "
1048 "expected v%u, got v%u.\n",
1050 IWL_ERR(drv
, "New firmware can be obtained from "
1051 "http://www.intellinuxwireless.org/.\n");
1056 * In mvm uCode there is no difference between data and instructions
1059 if (!fw
->mvm_fw
&& validate_sec_sizes(drv
, &pieces
, drv
->cfg
))
1062 /* Allocate ucode buffers for card's bus-master loading ... */
1064 /* Runtime instructions and 2 copies of data:
1065 * 1) unmodified from disk
1066 * 2) backup cache for save/restore during power-downs */
1067 for (i
= 0; i
< IWL_UCODE_TYPE_MAX
; i
++)
1068 if (iwl_alloc_ucode(drv
, &pieces
, i
))
1071 /* Now that we can no longer fail, copy information */
1074 * The (size - 16) / 12 formula is based on the information recorded
1075 * for each event, which is of mode 1 (including timestamp) for all
1076 * new microcodes that include this information.
1078 fw
->init_evtlog_ptr
= pieces
.init_evtlog_ptr
;
1079 if (pieces
.init_evtlog_size
)
1080 fw
->init_evtlog_size
= (pieces
.init_evtlog_size
- 16)/12;
1082 fw
->init_evtlog_size
=
1083 drv
->cfg
->base_params
->max_event_log_size
;
1084 fw
->init_errlog_ptr
= pieces
.init_errlog_ptr
;
1085 fw
->inst_evtlog_ptr
= pieces
.inst_evtlog_ptr
;
1086 if (pieces
.inst_evtlog_size
)
1087 fw
->inst_evtlog_size
= (pieces
.inst_evtlog_size
- 16)/12;
1089 fw
->inst_evtlog_size
=
1090 drv
->cfg
->base_params
->max_event_log_size
;
1091 fw
->inst_errlog_ptr
= pieces
.inst_errlog_ptr
;
1094 * figure out the offset of chain noise reset and gain commands
1095 * base on the size of standard phy calibration commands table size
1097 if (fw
->ucode_capa
.standard_phy_calibration_size
>
1098 IWL_MAX_PHY_CALIBRATE_TBL_SIZE
)
1099 fw
->ucode_capa
.standard_phy_calibration_size
=
1100 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE
;
1102 /* We have our copies now, allow OS release its copies */
1103 release_firmware(ucode_raw
);
1105 mutex_lock(&iwlwifi_opmode_table_mtx
);
1107 op
= &iwlwifi_opmode_table
[MVM_OP_MODE
];
1109 op
= &iwlwifi_opmode_table
[DVM_OP_MODE
];
1111 IWL_INFO(drv
, "loaded firmware version %s op_mode %s\n",
1112 drv
->fw
.fw_version
, op
->name
);
1114 /* add this device to the list of devices using this op_mode */
1115 list_add_tail(&drv
->list
, &op
->drv
);
1118 drv
->op_mode
= _iwl_op_mode_start(drv
, op
);
1120 if (!drv
->op_mode
) {
1121 mutex_unlock(&iwlwifi_opmode_table_mtx
);
1127 mutex_unlock(&iwlwifi_opmode_table_mtx
);
1130 * Complete the firmware request last so that
1131 * a driver unbind (stop) doesn't run while we
1132 * are doing the start() above.
1134 complete(&drv
->request_firmware_complete
);
1137 * Load the module last so we don't block anything
1138 * else from proceeding if the module fails to load
1142 err
= request_module("%s", op
->name
);
1143 #ifdef CONFIG_IWLWIFI_OPMODE_MODULAR
1146 "failed to load module %s (error %d), is dynamic loading enabled?\n",
1153 /* try next, if any */
1154 release_firmware(ucode_raw
);
1155 if (iwl_request_firmware(drv
, false))
1160 IWL_ERR(drv
, "failed to allocate pci memory\n");
1161 iwl_dealloc_ucode(drv
);
1162 release_firmware(ucode_raw
);
1164 complete(&drv
->request_firmware_complete
);
1165 device_release_driver(drv
->trans
->dev
);
1168 struct iwl_drv
*iwl_drv_start(struct iwl_trans
*trans
,
1169 const struct iwl_cfg
*cfg
)
1171 struct iwl_drv
*drv
;
1174 drv
= kzalloc(sizeof(*drv
), GFP_KERNEL
);
1181 drv
->dev
= trans
->dev
;
1184 init_completion(&drv
->request_firmware_complete
);
1185 INIT_LIST_HEAD(&drv
->list
);
1187 #ifdef CONFIG_IWLWIFI_DEBUGFS
1188 /* Create the device debugfs entries. */
1189 drv
->dbgfs_drv
= debugfs_create_dir(dev_name(trans
->dev
),
1192 if (!drv
->dbgfs_drv
) {
1193 IWL_ERR(drv
, "failed to create debugfs directory\n");
1198 /* Create transport layer debugfs dir */
1199 drv
->trans
->dbgfs_dir
= debugfs_create_dir("trans", drv
->dbgfs_drv
);
1201 if (!drv
->trans
->dbgfs_dir
) {
1202 IWL_ERR(drv
, "failed to create transport debugfs directory\n");
1204 goto err_free_dbgfs
;
1208 ret
= iwl_request_firmware(drv
, true);
1210 IWL_ERR(trans
, "Couldn't request the fw\n");
1217 #ifdef CONFIG_IWLWIFI_DEBUGFS
1219 debugfs_remove_recursive(drv
->dbgfs_drv
);
1224 return ERR_PTR(ret
);
1227 void iwl_drv_stop(struct iwl_drv
*drv
)
1229 wait_for_completion(&drv
->request_firmware_complete
);
1231 _iwl_op_mode_stop(drv
);
1233 iwl_dealloc_ucode(drv
);
1235 mutex_lock(&iwlwifi_opmode_table_mtx
);
1237 * List is empty (this item wasn't added)
1238 * when firmware loading failed -- in that
1239 * case we can't remove it from any list.
1241 if (!list_empty(&drv
->list
))
1242 list_del(&drv
->list
);
1243 mutex_unlock(&iwlwifi_opmode_table_mtx
);
1245 #ifdef CONFIG_IWLWIFI_DEBUGFS
1246 debugfs_remove_recursive(drv
->dbgfs_drv
);
1253 /* shared module parameters */
1254 struct iwl_mod_params iwlwifi_mod_params
= {
1256 .bt_coex_active
= true,
1257 .power_level
= IWL_POWER_INDEX_1
,
1259 #ifndef CONFIG_IWLWIFI_UAPSD
1260 .uapsd_disable
= true,
1261 #endif /* CONFIG_IWLWIFI_UAPSD */
1262 /* the rest are 0 by default */
1264 IWL_EXPORT_SYMBOL(iwlwifi_mod_params
);
1266 int iwl_opmode_register(const char *name
, const struct iwl_op_mode_ops
*ops
)
1269 struct iwl_drv
*drv
;
1270 struct iwlwifi_opmode_table
*op
;
1272 mutex_lock(&iwlwifi_opmode_table_mtx
);
1273 for (i
= 0; i
< ARRAY_SIZE(iwlwifi_opmode_table
); i
++) {
1274 op
= &iwlwifi_opmode_table
[i
];
1275 if (strcmp(op
->name
, name
))
1278 /* TODO: need to handle exceptional case */
1279 list_for_each_entry(drv
, &op
->drv
, list
)
1280 drv
->op_mode
= _iwl_op_mode_start(drv
, op
);
1282 mutex_unlock(&iwlwifi_opmode_table_mtx
);
1285 mutex_unlock(&iwlwifi_opmode_table_mtx
);
1288 IWL_EXPORT_SYMBOL(iwl_opmode_register
);
1290 void iwl_opmode_deregister(const char *name
)
1293 struct iwl_drv
*drv
;
1295 mutex_lock(&iwlwifi_opmode_table_mtx
);
1296 for (i
= 0; i
< ARRAY_SIZE(iwlwifi_opmode_table
); i
++) {
1297 if (strcmp(iwlwifi_opmode_table
[i
].name
, name
))
1299 iwlwifi_opmode_table
[i
].ops
= NULL
;
1301 /* call the stop routine for all devices */
1302 list_for_each_entry(drv
, &iwlwifi_opmode_table
[i
].drv
, list
)
1303 _iwl_op_mode_stop(drv
);
1305 mutex_unlock(&iwlwifi_opmode_table_mtx
);
1308 mutex_unlock(&iwlwifi_opmode_table_mtx
);
1310 IWL_EXPORT_SYMBOL(iwl_opmode_deregister
);
1312 static int __init
iwl_drv_init(void)
1316 mutex_init(&iwlwifi_opmode_table_mtx
);
1318 for (i
= 0; i
< ARRAY_SIZE(iwlwifi_opmode_table
); i
++)
1319 INIT_LIST_HEAD(&iwlwifi_opmode_table
[i
].drv
);
1321 pr_info(DRV_DESCRIPTION
", " DRV_VERSION
"\n");
1322 pr_info(DRV_COPYRIGHT
"\n");
1324 #ifdef CONFIG_IWLWIFI_DEBUGFS
1325 /* Create the root of iwlwifi debugfs subsystem. */
1326 iwl_dbgfs_root
= debugfs_create_dir(DRV_NAME
, NULL
);
1328 if (!iwl_dbgfs_root
)
1332 return iwl_pci_register_driver();
1334 module_init(iwl_drv_init
);
1336 static void __exit
iwl_drv_exit(void)
1338 iwl_pci_unregister_driver();
1340 #ifdef CONFIG_IWLWIFI_DEBUGFS
1341 debugfs_remove_recursive(iwl_dbgfs_root
);
1344 module_exit(iwl_drv_exit
);
1346 #ifdef CONFIG_IWLWIFI_DEBUG
1347 module_param_named(debug
, iwlwifi_mod_params
.debug_level
, uint
,
1349 MODULE_PARM_DESC(debug
, "debug output mask");
1352 module_param_named(swcrypto
, iwlwifi_mod_params
.sw_crypto
, int, S_IRUGO
);
1353 MODULE_PARM_DESC(swcrypto
, "using crypto in software (default 0 [hardware])");
1354 module_param_named(11n_disable
, iwlwifi_mod_params
.disable_11n
, uint
, S_IRUGO
);
1355 MODULE_PARM_DESC(11n_disable
,
1356 "disable 11n functionality, bitmap: 1: full, 2: disable agg TX, 4: disable agg RX, 8 enable agg TX");
1357 module_param_named(amsdu_size_8K
, iwlwifi_mod_params
.amsdu_size_8K
,
1359 MODULE_PARM_DESC(amsdu_size_8K
, "enable 8K amsdu size (default 0)");
1360 module_param_named(fw_restart
, iwlwifi_mod_params
.restart_fw
, bool, S_IRUGO
);
1361 MODULE_PARM_DESC(fw_restart
, "restart firmware in case of error (default true)");
1363 module_param_named(antenna_coupling
, iwlwifi_mod_params
.ant_coupling
,
1365 MODULE_PARM_DESC(antenna_coupling
,
1366 "specify antenna coupling in dB (defualt: 0 dB)");
1368 module_param_named(wd_disable
, iwlwifi_mod_params
.wd_disable
, int, S_IRUGO
);
1369 MODULE_PARM_DESC(wd_disable
,
1370 "Disable stuck queue watchdog timer 0=system default, 1=disable (default: 1)");
1372 module_param_named(nvm_file
, iwlwifi_mod_params
.nvm_file
, charp
, S_IRUGO
);
1373 MODULE_PARM_DESC(nvm_file
, "NVM file name");
1375 module_param_named(uapsd_disable
, iwlwifi_mod_params
.uapsd_disable
,
1377 #ifdef CONFIG_IWLWIFI_UAPSD
1378 MODULE_PARM_DESC(uapsd_disable
, "disable U-APSD functionality (default: N)");
1380 MODULE_PARM_DESC(uapsd_disable
, "disable U-APSD functionality (default: Y)");
1384 * set bt_coex_active to true, uCode will do kill/defer
1385 * every time the priority line is asserted (BT is sending signals on the
1386 * priority line in the PCIx).
1387 * set bt_coex_active to false, uCode will ignore the BT activity and
1388 * perform the normal operation
1390 * User might experience transmit issue on some platform due to WiFi/BT
1391 * co-exist problem. The possible behaviors are:
1392 * Able to scan and finding all the available AP
1393 * Not able to associate with any AP
1394 * On those platforms, WiFi communication can be restored by set
1395 * "bt_coex_active" module parameter to "false"
1397 * default: bt_coex_active = true (BT_COEX_ENABLE)
1399 module_param_named(bt_coex_active
, iwlwifi_mod_params
.bt_coex_active
,
1401 MODULE_PARM_DESC(bt_coex_active
, "enable wifi/bt co-exist (default: enable)");
1403 module_param_named(led_mode
, iwlwifi_mod_params
.led_mode
, int, S_IRUGO
);
1404 MODULE_PARM_DESC(led_mode
, "0=system default, "
1405 "1=On(RF On)/Off(RF Off), 2=blinking, 3=Off (default: 0)");
1407 module_param_named(power_save
, iwlwifi_mod_params
.power_save
,
1409 MODULE_PARM_DESC(power_save
,
1410 "enable WiFi power management (default: disable)");
1412 module_param_named(power_level
, iwlwifi_mod_params
.power_level
,
1414 MODULE_PARM_DESC(power_level
,
1415 "default power save level (range from 1 - 5, default: 1)");
1417 module_param_named(fw_monitor
, iwlwifi_mod_params
.fw_monitor
, bool, S_IRUGO
);
1418 MODULE_PARM_DESC(fw_monitor
,
1419 "firmware monitor - to debug FW (default: false - needs lots of memory)");