2 * Copyright (c) 2012-2015 Qualcomm Atheros, Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <linux/module.h>
18 #include <linux/pci.h>
19 #include <linux/moduleparam.h>
20 #include <linux/interrupt.h>
24 static bool use_msi
= true;
25 module_param(use_msi
, bool, S_IRUGO
);
26 MODULE_PARM_DESC(use_msi
, " Use MSI interrupt, default - true");
29 void wil_set_capabilities(struct wil6210_priv
*wil
)
31 u32 rev_id
= wil_r(wil
, RGF_USER_JTAG_DEV_ID
);
33 bitmap_zero(wil
->hw_capabilities
, hw_capability_last
);
36 case JTAG_DEV_ID_SPARROW_B0
:
37 wil
->hw_name
= "Sparrow B0";
38 wil
->hw_version
= HW_VER_SPARROW_B0
;
41 wil_err(wil
, "Unknown board hardware 0x%08x\n", rev_id
);
42 wil
->hw_name
= "Unknown";
43 wil
->hw_version
= HW_VER_UNKNOWN
;
46 wil_info(wil
, "Board hardware is %s\n", wil
->hw_name
);
49 void wil_disable_irq(struct wil6210_priv
*wil
)
51 disable_irq(wil
->pdev
->irq
);
54 void wil_enable_irq(struct wil6210_priv
*wil
)
56 enable_irq(wil
->pdev
->irq
);
60 static int wil_if_pcie_enable(struct wil6210_priv
*wil
)
62 struct pci_dev
*pdev
= wil
->pdev
;
64 /* on platforms with buggy ACPI, pdev->msi_enabled may be set to
65 * allow pci_enable_device to work. This indicates INTx was not routed
66 * and only MSI should be used
68 int msi_only
= pdev
->msi_enabled
;
69 bool _use_msi
= use_msi
;
71 wil_dbg_misc(wil
, "%s()\n", __func__
);
73 pdev
->msi_enabled
= 0;
77 wil_dbg_misc(wil
, "Setup %s interrupt\n", use_msi
? "MSI" : "INTx");
79 if (use_msi
&& pci_enable_msi(pdev
)) {
80 wil_err(wil
, "pci_enable_msi failed, use INTx\n");
84 if (!_use_msi
&& msi_only
) {
85 wil_err(wil
, "Interrupt pin not routed, unable to use INTx\n");
90 rc
= wil6210_init_irq(wil
, pdev
->irq
, _use_msi
);
94 /* need reset here to obtain MAC */
95 mutex_lock(&wil
->mutex
);
96 rc
= wil_reset(wil
, false);
97 mutex_unlock(&wil
->mutex
);
104 wil6210_fini_irq(wil
, pdev
->irq
);
105 /* safe to call if no MSI */
106 pci_disable_msi(pdev
);
108 pci_clear_master(pdev
);
112 static int wil_if_pcie_disable(struct wil6210_priv
*wil
)
114 struct pci_dev
*pdev
= wil
->pdev
;
116 wil_dbg_misc(wil
, "%s()\n", __func__
);
118 pci_clear_master(pdev
);
119 /* disable and release IRQ */
120 wil6210_fini_irq(wil
, pdev
->irq
);
121 /* safe to call if no MSI */
122 pci_disable_msi(pdev
);
123 /* TODO: disable HW */
128 static int wil_platform_rop_ramdump(void *wil_handle
, void *buf
, uint32_t size
)
130 struct wil6210_priv
*wil
= wil_handle
;
135 return wil_fw_copy_crash_dump(wil
, buf
, size
);
138 static int wil_platform_rop_fw_recovery(void *wil_handle
)
140 struct wil6210_priv
*wil
= wil_handle
;
145 wil_fw_error_recovery(wil
);
150 static int wil_pcie_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
152 struct wil6210_priv
*wil
;
153 struct device
*dev
= &pdev
->dev
;
155 const struct wil_platform_rops rops
= {
156 .ramdump
= wil_platform_rop_ramdump
,
157 .fw_recovery
= wil_platform_rop_fw_recovery
,
161 dev_info(&pdev
->dev
, WIL_NAME
162 " device found [%04x:%04x] (rev %x)\n",
163 (int)pdev
->vendor
, (int)pdev
->device
, (int)pdev
->revision
);
165 if (pci_resource_len(pdev
, 0) != WIL6210_MEM_SIZE
) {
166 dev_err(&pdev
->dev
, "Not " WIL_NAME
"? "
167 "BAR0 size is %lu while expecting %lu\n",
168 (ulong
)pci_resource_len(pdev
, 0), WIL6210_MEM_SIZE
);
172 wil
= wil_if_alloc(dev
);
174 rc
= (int)PTR_ERR(wil
);
175 dev_err(dev
, "wil_if_alloc failed: %d\n", rc
);
179 pci_set_drvdata(pdev
, wil
);
180 /* rollback to if_free */
182 wil
->platform_handle
=
183 wil_platform_init(&pdev
->dev
, &wil
->platform_ops
, &rops
, wil
);
184 if (!wil
->platform_handle
) {
186 wil_err(wil
, "wil_platform_init failed\n");
189 /* rollback to err_plat */
191 rc
= pci_enable_device(pdev
);
194 "pci_enable_device failed, retry with MSI only\n");
195 /* Work around for platforms that can't allocate IRQ:
196 * retry with MSI only
198 pdev
->msi_enabled
= 1;
199 rc
= pci_enable_device(pdev
);
203 "pci_enable_device failed, even with MSI only\n");
206 /* rollback to err_disable_pdev */
208 rc
= pci_request_region(pdev
, 0, WIL_NAME
);
210 wil_err(wil
, "pci_request_region failed\n");
211 goto err_disable_pdev
;
213 /* rollback to err_release_reg */
215 wil
->csr
= pci_ioremap_bar(pdev
, 0);
217 wil_err(wil
, "pci_ioremap_bar failed\n");
219 goto err_release_reg
;
221 /* rollback to err_iounmap */
222 wil_info(wil
, "CSR at %pR -> 0x%p\n", &pdev
->resource
[0], wil
->csr
);
224 wil_set_capabilities(wil
);
225 wil6210_clear_irq(wil
);
227 /* FW should raise IRQ when ready */
228 rc
= wil_if_pcie_enable(wil
);
230 wil_err(wil
, "Enable device failed\n");
233 /* rollback to bus_disable */
235 rc
= wil_if_add(wil
);
237 wil_err(wil
, "wil_if_add failed: %d\n", rc
);
241 wil6210_debugfs_init(wil
);
247 wil_if_pcie_disable(wil
);
249 pci_iounmap(pdev
, wil
->csr
);
251 pci_release_region(pdev
, 0);
253 pci_disable_device(pdev
);
255 if (wil
->platform_ops
.uninit
)
256 wil
->platform_ops
.uninit(wil
->platform_handle
);
263 static void wil_pcie_remove(struct pci_dev
*pdev
)
265 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
266 void __iomem
*csr
= wil
->csr
;
268 wil_dbg_misc(wil
, "%s()\n", __func__
);
270 wil6210_debugfs_remove(wil
);
272 wil_if_pcie_disable(wil
);
273 pci_iounmap(pdev
, csr
);
274 pci_release_region(pdev
, 0);
275 pci_disable_device(pdev
);
276 if (wil
->platform_ops
.uninit
)
277 wil
->platform_ops
.uninit(wil
->platform_handle
);
278 wil_p2p_wdev_free(wil
);
282 static const struct pci_device_id wil6210_pcie_ids
[] = {
283 { PCI_DEVICE(0x1ae9, 0x0310) },
284 { PCI_DEVICE(0x1ae9, 0x0302) }, /* same as above, firmware broken */
285 { /* end: all zeroes */ },
287 MODULE_DEVICE_TABLE(pci
, wil6210_pcie_ids
);
290 #ifdef CONFIG_PM_SLEEP
292 static int wil6210_suspend(struct device
*dev
, bool is_runtime
)
295 struct pci_dev
*pdev
= to_pci_dev(dev
);
296 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
298 wil_dbg_pm(wil
, "%s(%s)\n", __func__
,
299 is_runtime
? "runtime" : "system");
301 rc
= wil_can_suspend(wil
, is_runtime
);
305 rc
= wil_suspend(wil
, is_runtime
);
309 /* TODO: how do I bring card in low power state? */
311 /* disable bus mastering */
312 pci_clear_master(pdev
);
313 /* PCI will call pci_save_state(pdev) and pci_prepare_to_sleep(pdev) */
319 static int wil6210_resume(struct device
*dev
, bool is_runtime
)
322 struct pci_dev
*pdev
= to_pci_dev(dev
);
323 struct wil6210_priv
*wil
= pci_get_drvdata(pdev
);
325 wil_dbg_pm(wil
, "%s(%s)\n", __func__
,
326 is_runtime
? "runtime" : "system");
329 pci_set_master(pdev
);
331 rc
= wil_resume(wil
, is_runtime
);
333 pci_clear_master(pdev
);
338 static int wil6210_pm_suspend(struct device
*dev
)
340 return wil6210_suspend(dev
, false);
343 static int wil6210_pm_resume(struct device
*dev
)
345 return wil6210_resume(dev
, false);
347 #endif /* CONFIG_PM_SLEEP */
349 #endif /* CONFIG_PM */
351 static const struct dev_pm_ops wil6210_pm_ops
= {
352 SET_SYSTEM_SLEEP_PM_OPS(wil6210_pm_suspend
, wil6210_pm_resume
)
355 static struct pci_driver wil6210_driver
= {
356 .probe
= wil_pcie_probe
,
357 .remove
= wil_pcie_remove
,
358 .id_table
= wil6210_pcie_ids
,
361 .pm
= &wil6210_pm_ops
,
365 static int __init
wil6210_driver_init(void)
369 rc
= wil_platform_modinit();
373 rc
= pci_register_driver(&wil6210_driver
);
375 wil_platform_modexit();
378 module_init(wil6210_driver_init
);
380 static void __exit
wil6210_driver_exit(void)
382 pci_unregister_driver(&wil6210_driver
);
383 wil_platform_modexit();
385 module_exit(wil6210_driver_exit
);
387 MODULE_LICENSE("Dual BSD/GPL");
388 MODULE_AUTHOR("Qualcomm Atheros <wil6210@qca.qualcomm.com>");
389 MODULE_DESCRIPTION("Driver for 60g WiFi WIL6210 card");