drivers/net/wireless/ath/wil6210/pcie_bus.c

   1 /*
   2  * Copyright (c) 2012 Qualcomm Atheros, Inc.
   3  *
   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.
   7  *
   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.
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/pci.h>
  20 #include <linux/moduleparam.h>
  21
  22 #include "wil6210.h"
  23
  24 static int use_msi = 1;
  25 module_param(use_msi, int, S_IRUGO);
  26 MODULE_PARM_DESC(use_msi,
  27                  " Use MSI interrupt: "
  28                  "0 - don't, 1 - (default) - single, or 3");
  29
  30 /* Bus ops */
  31 static int wil_if_pcie_enable(struct wil6210_priv *wil)
  32 {
  33         struct pci_dev *pdev = wil->pdev;
  34         int rc;
  35
  36         pci_set_master(pdev);
  37
  38         /*
  39          * how many MSI interrupts to request?
  40          */
  41         switch (use_msi) {
  42         case 3:
  43         case 1:
  44         case 0:
  45                 break;
  46         default:
  47                 wil_err(wil, "Invalid use_msi=%d, default to 1\n",
  48                         use_msi);
  49                 use_msi = 1;
  50         }
  51         wil->n_msi = use_msi;
  52         if (wil->n_msi) {
  53                 wil_dbg_misc(wil, "Setup %d MSI interrupts\n", use_msi);
  54                 rc = pci_enable_msi_block(pdev, wil->n_msi);
  55                 if (rc && (wil->n_msi == 3)) {
  56                         wil_err(wil, "3 MSI mode failed, try 1 MSI\n");
  57                         wil->n_msi = 1;
  58                         rc = pci_enable_msi_block(pdev, wil->n_msi);
  59                 }
  60                 if (rc) {
  61                         wil_err(wil, "pci_enable_msi failed, use INTx\n");
  62                         wil->n_msi = 0;
  63                 }
  64         } else {
  65                 wil_dbg_misc(wil, "MSI interrupts disabled, use INTx\n");
  66         }
  67
  68         rc = wil6210_init_irq(wil, pdev->irq);
  69         if (rc)
  70                 goto stop_master;
  71
  72         /* need reset here to obtain MAC */
  73         rc = wil_reset(wil);
  74         if (rc)
  75                 goto release_irq;
  76
  77         wil_info(wil, "HW version: 0x%08x\n", wil->hw_version);
  78
  79         return 0;
  80
  81  release_irq:
  82         wil6210_fini_irq(wil, pdev->irq);
  83         /* safe to call if no MSI */
  84         pci_disable_msi(pdev);
  85  stop_master:
  86         pci_clear_master(pdev);
  87         return rc;
  88 }
  89
  90 static int wil_if_pcie_disable(struct wil6210_priv *wil)
  91 {
  92         struct pci_dev *pdev = wil->pdev;
  93
  94         pci_clear_master(pdev);
  95         /* disable and release IRQ */
  96         wil6210_fini_irq(wil, pdev->irq);
  97         /* safe to call if no MSI */
  98         pci_disable_msi(pdev);
  99         /* TODO: disable HW */
 100
 101         return 0;
 102 }
 103
 104 static int wil_pcie_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 105 {
 106         struct wil6210_priv *wil;
 107         struct device *dev = &pdev->dev;
 108         void __iomem *csr;
 109         int rc;
 110
 111         /* check HW */
 112         dev_info(&pdev->dev, WIL_NAME " device found [%04x:%04x] (rev %x)\n",
 113                  (int)pdev->vendor, (int)pdev->device, (int)pdev->revision);
 114
 115         if (pci_resource_len(pdev, 0) != WIL6210_MEM_SIZE) {
 116                 dev_err(&pdev->dev, "Not " WIL_NAME "? "
 117                         "BAR0 size is %lu while expecting %lu\n",
 118                         (ulong)pci_resource_len(pdev, 0), WIL6210_MEM_SIZE);
 119                 return -ENODEV;
 120         }
 121
 122         rc = pci_enable_device(pdev);
 123         if (rc) {
 124                 dev_err(&pdev->dev, "pci_enable_device failed\n");
 125                 return -ENODEV;
 126         }
 127         /* rollback to err_disable_pdev */
 128
 129         rc = pci_request_region(pdev, 0, WIL_NAME);
 130         if (rc) {
 131                 dev_err(&pdev->dev, "pci_request_region failed\n");
 132                 goto err_disable_pdev;
 133         }
 134         /* rollback to err_release_reg */
 135
 136         csr = pci_ioremap_bar(pdev, 0);
 137         if (!csr) {
 138                 dev_err(&pdev->dev, "pci_ioremap_bar failed\n");
 139                 rc = -ENODEV;
 140                 goto err_release_reg;
 141         }
 142         /* rollback to err_iounmap */
 143         dev_info(&pdev->dev, "CSR at %pR -> %p\n", &pdev->resource[0], csr);
 144
 145         wil = wil_if_alloc(dev, csr);
 146         if (IS_ERR(wil)) {
 147                 rc = (int)PTR_ERR(wil);
 148                 dev_err(dev, "wil_if_alloc failed: %d\n", rc);
 149                 goto err_iounmap;
 150         }
 151         /* rollback to if_free */
 152
 153         pci_set_drvdata(pdev, wil);
 154         wil->pdev = pdev;
 155
 156         /* FW should raise IRQ when ready */
 157         rc = wil_if_pcie_enable(wil);
 158         if (rc) {
 159                 wil_err(wil, "Enable device failed\n");
 160                 goto if_free;
 161         }
 162         /* rollback to bus_disable */
 163
 164         rc = wil_if_add(wil);
 165         if (rc) {
 166                 wil_err(wil, "wil_if_add failed: %d\n", rc);
 167                 goto bus_disable;
 168         }
 169
 170         wil6210_debugfs_init(wil);
 171
 172         /* check FW is alive */
 173         wmi_echo(wil);
 174
 175         return 0;
 176
 177  bus_disable:
 178         wil_if_pcie_disable(wil);
 179  if_free:
 180         wil_if_free(wil);
 181  err_iounmap:
 182         pci_iounmap(pdev, csr);
 183  err_release_reg:
 184         pci_release_region(pdev, 0);
 185  err_disable_pdev:
 186         pci_disable_device(pdev);
 187
 188         return rc;
 189 }
 190
 191 static void wil_pcie_remove(struct pci_dev *pdev)
 192 {
 193         struct wil6210_priv *wil = pci_get_drvdata(pdev);
 194
 195         wil6210_debugfs_remove(wil);
 196         wil_if_pcie_disable(wil);
 197         wil_if_remove(wil);
 198         wil_if_free(wil);
 199         pci_iounmap(pdev, wil->csr);
 200         pci_release_region(pdev, 0);
 201         pci_disable_device(pdev);
 202 }
 203
 204 static DEFINE_PCI_DEVICE_TABLE(wil6210_pcie_ids) = {
 205         { PCI_DEVICE(0x1ae9, 0x0301) },
 206         { /* end: all zeroes */ },
 207 };
 208 MODULE_DEVICE_TABLE(pci, wil6210_pcie_ids);
 209
 210 static struct pci_driver wil6210_driver = {
 211         .probe          = wil_pcie_probe,
 212         .remove         = wil_pcie_remove,
 213         .id_table       = wil6210_pcie_ids,
 214         .name           = WIL_NAME,
 215 };
 216
 217 module_pci_driver(wil6210_driver);
 218
 219 MODULE_LICENSE("Dual BSD/GPL");
 220 MODULE_AUTHOR("Qualcomm Atheros <wil6210@qca.qualcomm.com>");
 221 MODULE_DESCRIPTION("Driver for 60g WiFi WIL6210 card");