2 * Copyright (c) 2012-2017 Qualcomm Atheros, Inc.
3 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 #include <linux/module.h>
19 #include <linux/pci.h>
20 #include <linux/moduleparam.h>
21 #include <linux/interrupt.h>
22 #include <linux/suspend.h>
24 #include <linux/rtnetlink.h>
25 #include <linux/pm_runtime.h>
28 module_param(n_msi
, int, 0444);
29 MODULE_PARM_DESC(n_msi
, " Use MSI interrupt: 0 - use INTx, 1 - single, or 3 - (default) ");
32 module_param(ftm_mode
, bool, 0444);
33 MODULE_PARM_DESC(ftm_mode
, " Set factory test mode, default - false");
35 static int wil6210_pm_notify(struct notifier_block
*notify_block
,
36 unsigned long mode
, void *unused
);
39 int wil_set_capabilities(struct wil6210_priv
*wil
)
41 const char *wil_fw_name
;
42 u32 jtag_id
= wil_r(wil
, RGF_USER_JTAG_DEV_ID
);
43 u8 chip_revision
= (wil_r(wil
, RGF_USER_REVISION_ID
) &
44 RGF_USER_REVISION_ID_MASK
);
46 struct fw_map
*iccm_section
, *sct
;
48 bitmap_zero(wil
->hw_capa
, hw_capa_last
);
49 bitmap_zero(wil
->fw_capabilities
, WMI_FW_CAPABILITY_MAX
);
50 bitmap_zero(wil
->platform_capa
, WIL_PLATFORM_CAPA_MAX
);
51 wil
->wil_fw_name
= ftm_mode
? WIL_FW_NAME_FTM_DEFAULT
:
53 wil
->chip_revision
= chip_revision
;
56 case JTAG_DEV_ID_SPARROW
:
57 memcpy(fw_mapping
, sparrow_fw_mapping
,
58 sizeof(sparrow_fw_mapping
));
59 switch (chip_revision
) {
60 case REVISION_ID_SPARROW_D0
:
61 wil
->hw_name
= "Sparrow D0";
62 wil
->hw_version
= HW_VER_SPARROW_D0
;
63 wil_fw_name
= ftm_mode
? WIL_FW_NAME_FTM_SPARROW_PLUS
:
64 WIL_FW_NAME_SPARROW_PLUS
;
66 if (wil_fw_verify_file_exists(wil
, wil_fw_name
))
67 wil
->wil_fw_name
= wil_fw_name
;
68 sct
= wil_find_fw_mapping("mac_rgf_ext");
70 wil_err(wil
, "mac_rgf_ext section not found in fw_mapping\n");
73 memcpy(sct
, &sparrow_d0_mac_rgf_ext
, sizeof(*sct
));
75 case REVISION_ID_SPARROW_B0
:
76 wil
->hw_name
= "Sparrow B0";
77 wil
->hw_version
= HW_VER_SPARROW_B0
;
80 wil
->hw_name
= "Unknown";
81 wil
->hw_version
= HW_VER_UNKNOWN
;
84 wil
->rgf_fw_assert_code_addr
= SPARROW_RGF_FW_ASSERT_CODE
;
85 wil
->rgf_ucode_assert_code_addr
= SPARROW_RGF_UCODE_ASSERT_CODE
;
87 case JTAG_DEV_ID_TALYN
:
88 wil
->hw_name
= "Talyn-MA";
89 wil
->hw_version
= HW_VER_TALYN
;
90 memcpy(fw_mapping
, talyn_fw_mapping
, sizeof(talyn_fw_mapping
));
91 wil
->rgf_fw_assert_code_addr
= TALYN_RGF_FW_ASSERT_CODE
;
92 wil
->rgf_ucode_assert_code_addr
= TALYN_RGF_UCODE_ASSERT_CODE
;
93 if (wil_r(wil
, RGF_USER_OTP_HW_RD_MACHINE_1
) &
94 BIT_NO_FLASH_INDICATION
)
95 set_bit(hw_capa_no_flash
, wil
->hw_capa
);
96 wil_fw_name
= ftm_mode
? WIL_FW_NAME_FTM_TALYN
:
98 if (wil_fw_verify_file_exists(wil
, wil_fw_name
))
99 wil
->wil_fw_name
= wil_fw_name
;
101 case JTAG_DEV_ID_TALYN_MB
:
102 wil
->hw_name
= "Talyn-MB";
103 wil
->hw_version
= HW_VER_TALYN_MB
;
104 memcpy(fw_mapping
, talyn_mb_fw_mapping
,
105 sizeof(talyn_mb_fw_mapping
));
106 wil
->rgf_fw_assert_code_addr
= TALYN_RGF_FW_ASSERT_CODE
;
107 wil
->rgf_ucode_assert_code_addr
= TALYN_RGF_UCODE_ASSERT_CODE
;
108 set_bit(hw_capa_no_flash
, wil
->hw_capa
);
109 wil
->use_enhanced_dma_hw
= true;
110 wil
->use_rx_hw_reordering
= true;
111 wil
->use_compressed_rx_status
= true;
112 wil_fw_name
= ftm_mode
? WIL_FW_NAME_FTM_TALYN
:
114 if (wil_fw_verify_file_exists(wil
, wil_fw_name
))
115 wil
->wil_fw_name
= wil_fw_name
;
118 wil_err(wil
, "Unknown board hardware, chip_id 0x%08x, chip_revision 0x%08x\n",
119 jtag_id
, chip_revision
);
120 wil
->hw_name
= "Unknown";
121 wil
->hw_version
= HW_VER_UNKNOWN
;
125 wil_init_txrx_ops(wil
);
127 iccm_section
= wil_find_fw_mapping("fw_code");
129 wil_err(wil
, "fw_code section not found in fw_mapping\n");
132 wil
->iccm_base
= iccm_section
->host
;
134 wil_info(wil
, "Board hardware is %s, flash %sexist\n", wil
->hw_name
,
135 test_bit(hw_capa_no_flash
, wil
->hw_capa
) ? "doesn't " : "");
137 /* Get platform capabilities */
138 if (wil
->platform_ops
.get_capa
) {
140 wil
->platform_ops
.get_capa(wil
->platform_handle
);
141 memcpy(wil
->platform_capa
, &platform_capa
,
142 min(sizeof(wil
->platform_capa
), sizeof(platform_capa
)));
145 wil_info(wil
, "platform_capa 0x%lx\n", *wil
->platform_capa
);
147 /* extract FW capabilities from file without loading the FW */
148 wil_request_firmware(wil
, wil
->wil_fw_name
, false);
149 wil_refresh_fw_capabilities(wil
);
154 void wil_disable_irq(struct wil6210_priv
*wil
)
156 int irq
= wil
->pdev
->irq
;
159 if (wil
->n_msi
== 3) {
160 disable_irq(irq
+ 1);
161 disable_irq(irq
+ 2);
165 void wil_enable_irq(struct wil6210_priv
*wil
)
167 int irq
= wil
->pdev
->irq
;
170 if (wil
->n_msi
== 3) {
176 static void wil_remove_all_additional_vifs(struct wil6210_priv
*wil
)
178 struct wil6210_vif
*vif
;
181 for (i
= 1; i
< GET_MAX_VIFS(wil
); i
++) {
184 wil_vif_prepare_stop(vif
);
185 wil_vif_remove(wil
, vif
->mid
);
191 static int wil_if_pcie_enable(struct wil6210_priv
*wil
)
193 struct pci_dev
*pdev
= wil
->pdev
;
195 /* on platforms with buggy ACPI, pdev->msi_enabled may be set to
196 * allow pci_enable_device to work. This indicates INTx was not routed
197 * and only MSI should be used
199 int msi_only
= pdev
->msi_enabled
;
201 wil_dbg_misc(wil
, "if_pcie_enable\n");
203 pci_set_master(pdev
);
205 /* how many MSI interrupts to request? */
209 wil_dbg_misc(wil
, "Setup %d MSI interrupts\n", n_msi
);
212 wil_dbg_misc(wil
, "MSI interrupts disabled, use INTx\n");
215 wil_err(wil
, "Invalid n_msi=%d, default to 1\n", n_msi
);
220 pci_alloc_irq_vectors(pdev
, n_msi
, n_msi
, PCI_IRQ_MSI
) < n_msi
) {
221 wil_err(wil
, "3 MSI mode failed, try 1 MSI\n");
225 if (n_msi
== 1 && pci_enable_msi(pdev
)) {
226 wil_err(wil
, "pci_enable_msi failed, use INTx\n");
232 if (wil
->n_msi
== 0 && msi_only
) {
233 wil_err(wil
, "Interrupt pin not routed, unable to use INTx\n");
238 rc
= wil6210_init_irq(wil
, pdev
->irq
);
240 goto release_vectors
;
242 /* need reset here to obtain MAC */
243 mutex_lock(&wil
->mutex
);
244 rc
= wil_reset(wil
, false);
245 mutex_unlock(&wil
->mutex
);
252 wil6210_fini_irq(wil
, pdev
->irq
);
254 /* safe to call if no allocation */
255 pci_free_irq_vectors(pdev
);
257 pci_clear_master(pdev
);
261 static int wil_if_pcie_disable(struct wil6210_priv
*wil
)
263 struct pci_dev
*pdev
= wil
->pdev
;
265 wil_dbg_misc(wil
, "if_pcie_disable\n");
267 pci_clear_master(pdev
);
268 /* disable and release IRQ */
269 wil6210_fini_irq(wil
, pdev
->irq
);
270 /* safe to call if no MSI */
271 pci_disable_msi(pdev
);
272 /* TODO: disable HW */
277 static int wil_platform_rop_ramdump(void *wil_handle
, void *buf
, uint32_t size
)
279 struct wil6210_priv
*wil
= wil_handle
;
284 return wil_fw_copy_crash_dump(wil
, buf
, size
);
287 static int wil_platform_rop_fw_recovery(void *wil_handle
)
289 struct wil6210_priv
*wil
= wil_handle
;
294 wil_fw_error_recovery(wil
);
299 static void wil_platform_ops_uninit(struct wil6210_priv
*wil
)
301 if (wil
->platform_ops
.uninit
)
302 wil
->platform_ops
.uninit(wil
->platform_handle
);
303 memset(&wil
->platform_ops
, 0, sizeof(wil
->platform_ops
));
306 static int wil_pcie_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
308 struct wil6210_priv
*wil
;
309 struct device
*dev
= &pdev
->dev
;
311 const struct wil_platform_rops rops
= {
312 .ramdump
= wil_platform_rop_ramdump
,
313 .fw_recovery
= wil_platform_rop_fw_recovery
,
315 u32 bar_size
= pci_resource_len(pdev
, 0);
316 int dma_addr_size
[] = {64, 48, 40, 32}; /* keep descending order */
320 dev_info(&pdev
->dev
, WIL_NAME
321 " device found [%04x:%04x] (rev %x) bar size 0x%x\n",
322 (int)pdev
->vendor
, (int)pdev
->device
, (int)pdev
->revision
,
325 if ((bar_size
< WIL6210_MIN_MEM_SIZE
) ||
326 (bar_size
> WIL6210_MAX_MEM_SIZE
)) {
327 dev_err(&pdev
->dev
, "Unexpected BAR0 size 0x%x\n",
332 wil
= wil_if_alloc(dev
);
334 rc
= (int)PTR_ERR(wil
);
335 dev_err(dev
, "wil_if_alloc failed: %d\n", rc
);
340 pci_set_drvdata(pdev
, wil
);
341 wil
->bar_size
= bar_size
;
342 /* rollback to if_free */
344 wil
->platform_handle
=
345 wil_platform_init(&pdev
->dev
, &wil
->platform_ops
, &rops
, wil
);
346 if (!wil
->platform_handle
) {
348 wil_err(wil
, "wil_platform_init failed\n");
351 /* rollback to err_plat */
352 rc
= pci_enable_device(pdev
);
353 if (rc
&& pdev
->msi_enabled
== 0) {
355 "pci_enable_device failed, retry with MSI only\n");
356 /* Work around for platforms that can't allocate IRQ:
357 * retry with MSI only
359 pdev
->msi_enabled
= 1;
360 rc
= pci_enable_device(pdev
);
364 "pci_enable_device failed, even with MSI only\n");
367 /* rollback to err_disable_pdev */
368 pci_set_power_state(pdev
, PCI_D0
);
370 rc
= pci_request_region(pdev
, 0, WIL_NAME
);
372 wil_err(wil
, "pci_request_region failed\n");
373 goto err_disable_pdev
;
375 /* rollback to err_release_reg */
377 wil
->csr
= pci_ioremap_bar(pdev
, 0);
379 wil_err(wil
, "pci_ioremap_bar failed\n");
381 goto err_release_reg
;
383 /* rollback to err_iounmap */
384 wil_info(wil
, "CSR at %pR -> 0x%p\n", &pdev
->resource
[0], wil
->csr
);
386 rc
= wil_set_capabilities(wil
);
388 wil_err(wil
, "wil_set_capabilities failed, rc %d\n", rc
);
392 /* device supports >32bit addresses.
393 * for legacy DMA start from 48 bit.
395 start_idx
= wil
->use_enhanced_dma_hw
? 0 : 1;
397 for (i
= start_idx
; i
< ARRAY_SIZE(dma_addr_size
); i
++) {
398 rc
= dma_set_mask_and_coherent(dev
,
399 DMA_BIT_MASK(dma_addr_size
[i
]));
401 dev_err(dev
, "dma_set_mask_and_coherent(%d) failed: %d\n",
402 dma_addr_size
[i
], rc
);
405 dev_info(dev
, "using dma mask %d", dma_addr_size
[i
]);
406 wil
->dma_addr_size
= dma_addr_size
[i
];
410 if (wil
->dma_addr_size
== 0)
413 wil6210_clear_irq(wil
);
415 /* FW should raise IRQ when ready */
416 rc
= wil_if_pcie_enable(wil
);
418 wil_err(wil
, "Enable device failed\n");
421 /* rollback to bus_disable */
423 wil_clear_fw_log_addr(wil
);
424 rc
= wil_if_add(wil
);
426 wil_err(wil
, "wil_if_add failed: %d\n", rc
);
430 /* in case of WMI-only FW, perform full reset and FW loading */
431 if (test_bit(WMI_FW_CAPABILITY_WMI_ONLY
, wil
->fw_capabilities
)) {
432 wil_dbg_misc(wil
, "Loading WMI only FW\n");
433 mutex_lock(&wil
->mutex
);
434 rc
= wil_reset(wil
, true);
435 mutex_unlock(&wil
->mutex
);
437 wil_err(wil
, "failed to load WMI only FW\n");
438 /* ignore the error to allow debugging */
442 if (IS_ENABLED(CONFIG_PM
))
443 wil
->pm_notify
.notifier_call
= wil6210_pm_notify
;
445 rc
= register_pm_notifier(&wil
->pm_notify
);
447 /* Do not fail the driver initialization, as suspend can
448 * be prevented in a later phase if needed
450 wil_err(wil
, "register_pm_notifier failed: %d\n", rc
);
452 wil6210_debugfs_init(wil
);
454 wil_pm_runtime_allow(wil
);
459 wil_if_pcie_disable(wil
);
461 pci_iounmap(pdev
, wil
->csr
);
463 pci_release_region(pdev
, 0);
465 pci_disable_device(pdev
);
467 wil_platform_ops_uninit(wil
);
474 static void wil_pcie_remove(struct pci_dev
*pdev
)
476 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
477 void __iomem
*csr
= wil
->csr
;
479 wil_dbg_misc(wil
, "pcie_remove\n");
481 unregister_pm_notifier(&wil
->pm_notify
);
483 wil_pm_runtime_forbid(wil
);
485 wil6210_debugfs_remove(wil
);
487 wil_p2p_wdev_free(wil
);
488 wil_remove_all_additional_vifs(wil
);
491 wil_if_pcie_disable(wil
);
492 pci_iounmap(pdev
, csr
);
493 pci_release_region(pdev
, 0);
494 pci_disable_device(pdev
);
495 wil_platform_ops_uninit(wil
);
499 static const struct pci_device_id wil6210_pcie_ids
[] = {
500 { PCI_DEVICE(0x1ae9, 0x0310) },
501 { PCI_DEVICE(0x1ae9, 0x0302) }, /* same as above, firmware broken */
502 { PCI_DEVICE(0x17cb, 0x1201) }, /* Talyn */
503 { /* end: all zeroes */ },
505 MODULE_DEVICE_TABLE(pci
, wil6210_pcie_ids
);
507 static int wil6210_suspend(struct device
*dev
, bool is_runtime
)
510 struct pci_dev
*pdev
= to_pci_dev(dev
);
511 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
512 bool keep_radio_on
, active_ifaces
;
514 wil_dbg_pm(wil
, "suspend: %s\n", is_runtime
? "runtime" : "system");
516 mutex_lock(&wil
->vif_mutex
);
517 active_ifaces
= wil_has_active_ifaces(wil
, true, false);
518 mutex_unlock(&wil
->vif_mutex
);
519 keep_radio_on
= active_ifaces
&& wil
->keep_radio_on_during_sleep
;
521 rc
= wil_can_suspend(wil
, is_runtime
);
525 rc
= wil_suspend(wil
, is_runtime
, keep_radio_on
);
527 /* In case radio stays on, platform device will control
530 if (!keep_radio_on
) {
531 /* disable bus mastering */
532 pci_clear_master(pdev
);
533 wil
->suspend_stats
.r_off
.successful_suspends
++;
535 wil
->suspend_stats
.r_on
.successful_suspends
++;
542 static int wil6210_resume(struct device
*dev
, bool is_runtime
)
545 struct pci_dev
*pdev
= to_pci_dev(dev
);
546 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
547 bool keep_radio_on
, active_ifaces
;
549 wil_dbg_pm(wil
, "resume: %s\n", is_runtime
? "runtime" : "system");
551 mutex_lock(&wil
->vif_mutex
);
552 active_ifaces
= wil_has_active_ifaces(wil
, true, false);
553 mutex_unlock(&wil
->vif_mutex
);
554 keep_radio_on
= active_ifaces
&& wil
->keep_radio_on_during_sleep
;
556 /* In case radio stays on, platform device will control
561 pci_set_master(pdev
);
562 rc
= wil_resume(wil
, is_runtime
, keep_radio_on
);
564 wil_err(wil
, "device failed to resume (%d)\n", rc
);
565 if (!keep_radio_on
) {
566 pci_clear_master(pdev
);
567 wil
->suspend_stats
.r_off
.failed_resumes
++;
569 wil
->suspend_stats
.r_on
.failed_resumes
++;
573 wil
->suspend_stats
.r_on
.successful_resumes
++;
575 wil
->suspend_stats
.r_off
.successful_resumes
++;
581 static int wil6210_pm_notify(struct notifier_block
*notify_block
,
582 unsigned long mode
, void *unused
)
584 struct wil6210_priv
*wil
= container_of(
585 notify_block
, struct wil6210_priv
, pm_notify
);
587 enum wil_platform_event evt
;
589 wil_dbg_pm(wil
, "pm_notify: mode (%ld)\n", mode
);
592 case PM_HIBERNATION_PREPARE
:
593 case PM_SUSPEND_PREPARE
:
594 case PM_RESTORE_PREPARE
:
595 rc
= wil_can_suspend(wil
, false);
598 evt
= WIL_PLATFORM_EVT_PRE_SUSPEND
;
599 if (wil
->platform_ops
.notify
)
600 rc
= wil
->platform_ops
.notify(wil
->platform_handle
,
603 case PM_POST_SUSPEND
:
604 case PM_POST_HIBERNATION
:
605 case PM_POST_RESTORE
:
606 evt
= WIL_PLATFORM_EVT_POST_SUSPEND
;
607 if (wil
->platform_ops
.notify
)
608 rc
= wil
->platform_ops
.notify(wil
->platform_handle
,
612 wil_dbg_pm(wil
, "unhandled notify mode %ld\n", mode
);
616 wil_dbg_pm(wil
, "notification mode %ld: rc (%d)\n", mode
, rc
);
620 static int __maybe_unused
wil6210_pm_suspend(struct device
*dev
)
622 return wil6210_suspend(dev
, false);
625 static int __maybe_unused
wil6210_pm_resume(struct device
*dev
)
627 return wil6210_resume(dev
, false);
630 static int __maybe_unused
wil6210_pm_runtime_idle(struct device
*dev
)
632 struct pci_dev
*pdev
= to_pci_dev(dev
);
633 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
635 wil_dbg_pm(wil
, "Runtime idle\n");
637 return wil_can_suspend(wil
, true);
640 static int __maybe_unused
wil6210_pm_runtime_resume(struct device
*dev
)
642 return wil6210_resume(dev
, true);
645 static int __maybe_unused
wil6210_pm_runtime_suspend(struct device
*dev
)
647 struct pci_dev
*pdev
= to_pci_dev(dev
);
648 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
650 if (test_bit(wil_status_suspended
, wil
->status
)) {
651 wil_dbg_pm(wil
, "trying to suspend while suspended\n");
655 return wil6210_suspend(dev
, true);
658 static const struct dev_pm_ops wil6210_pm_ops
= {
659 SET_SYSTEM_SLEEP_PM_OPS(wil6210_pm_suspend
, wil6210_pm_resume
)
660 SET_RUNTIME_PM_OPS(wil6210_pm_runtime_suspend
,
661 wil6210_pm_runtime_resume
,
662 wil6210_pm_runtime_idle
)
665 static struct pci_driver wil6210_driver
= {
666 .probe
= wil_pcie_probe
,
667 .remove
= wil_pcie_remove
,
668 .id_table
= wil6210_pcie_ids
,
671 .pm
= &wil6210_pm_ops
,
675 static int __init
wil6210_driver_init(void)
679 rc
= wil_platform_modinit();
683 rc
= pci_register_driver(&wil6210_driver
);
685 wil_platform_modexit();
688 module_init(wil6210_driver_init
);
690 static void __exit
wil6210_driver_exit(void)
692 pci_unregister_driver(&wil6210_driver
);
693 wil_platform_modexit();
695 module_exit(wil6210_driver_exit
);
697 MODULE_LICENSE("Dual BSD/GPL");
698 MODULE_AUTHOR("Qualcomm Atheros <wil6210@qca.qualcomm.com>");
699 MODULE_DESCRIPTION("Driver for 60g WiFi WIL6210 card");