drivers/net/wireless/ath/ath9k/ath9k_pci_owl_loader.c

   1 // SPDX-License-Identifier: ISC
   2 /* Initialize Owl Emulation Devices
   3  *
   4  * Copyright (C) 2016 Christian Lamparter <chunkeey@gmail.com>
   5  * Copyright (C) 2016 Martin Blumenstingl <martin.blumenstingl@googlemail.com>
   6  *
   7  * Some devices (like the Cisco Meraki Z1 Cloud Managed Teleworker Gateway)
   8  * need to be able to initialize the PCIe wifi device. Normally, this is done
   9  * during the early stages as a pci quirk.
  10  * However, this isn't possible for devices which have the init code for the
  11  * Atheros chip stored on UBI Volume on NAND. Hence, this module can be used to
  12  * initialize the chip when the user-space is ready to extract the init code.
  13  */
  14 #include <linux/module.h>
  15 #include <linux/completion.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/firmware.h>
  18 #include <linux/pci.h>
  19 #include <linux/delay.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/ath9k_platform.h>
  22
  23 struct owl_ctx {
  24         struct completion eeprom_load;
  25 };
  26
  27 #define EEPROM_FILENAME_LEN 100
  28
  29 #define AR5416_EEPROM_MAGIC 0xa55a
  30
  31 static int ath9k_pci_fixup(struct pci_dev *pdev, const u16 *cal_data,
  32                            size_t cal_len)
  33 {
  34         void __iomem *mem;
  35         const void *cal_end = (void *)cal_data + cal_len;
  36         const struct {
  37                 u16 reg;
  38                 u16 low_val;
  39                 u16 high_val;
  40         } __packed * data;
  41         u16 cmd;
  42         u32 bar0;
  43         bool swap_needed = false;
  44
  45         if (*cal_data != AR5416_EEPROM_MAGIC) {
  46                 if (*cal_data != swab16(AR5416_EEPROM_MAGIC)) {
  47                         dev_err(&pdev->dev, "invalid calibration data\n");
  48                         return -EINVAL;
  49                 }
  50
  51                 dev_dbg(&pdev->dev, "calibration data needs swapping\n");
  52                 swap_needed = true;
  53         }
  54
  55         dev_info(&pdev->dev, "fixup device configuration\n");
  56
  57         mem = pcim_iomap(pdev, 0, 0);
  58         if (!mem) {
  59                 dev_err(&pdev->dev, "ioremap error\n");
  60                 return -EINVAL;
  61         }
  62
  63         pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &bar0);
  64         pci_write_config_dword(pdev, PCI_BASE_ADDRESS_0,
  65                                pci_resource_start(pdev, 0));
  66         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  67         cmd |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
  68         pci_write_config_word(pdev, PCI_COMMAND, cmd);
  69
  70         /* set pointer to first reg address */
  71         for (data = (const void *)(cal_data + 3);
  72              (const void *)data <= cal_end && data->reg != (u16)~0;
  73              data++) {
  74                 u32 val;
  75                 u16 reg;
  76
  77                 reg = data->reg;
  78                 val = data->low_val;
  79                 val |= ((u32)data->high_val) << 16;
  80
  81                 if (swap_needed) {
  82                         reg = swab16(reg);
  83                         val = swahb32(val);
  84                 }
  85
  86                 iowrite32(val, mem + reg);
  87                 usleep_range(100, 120);
  88         }
  89
  90         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
  91         cmd &= ~(PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY);
  92         pci_write_config_word(pdev, PCI_COMMAND, cmd);
  93
  94         pci_write_config_dword(pdev, PCI_BASE_ADDRESS_0, bar0);
  95         pcim_iounmap(pdev, mem);
  96
  97         pci_disable_device(pdev);
  98
  99         return 0;
 100 }
 101
 102 static void owl_fw_cb(const struct firmware *fw, void *context)
 103 {
 104         struct pci_dev *pdev = (struct pci_dev *)context;
 105         struct owl_ctx *ctx = (struct owl_ctx *)pci_get_drvdata(pdev);
 106         struct pci_bus *bus;
 107
 108         complete(&ctx->eeprom_load);
 109
 110         if (!fw) {
 111                 dev_err(&pdev->dev, "no eeprom data received.\n");
 112                 goto release;
 113         }
 114
 115         /* also note that we are doing *u16 operations on the file */
 116         if (fw->size > 4096 || fw->size < 0x200 || (fw->size & 1) == 1) {
 117                 dev_err(&pdev->dev, "eeprom file has an invalid size.\n");
 118                 goto release;
 119         }
 120
 121         if (ath9k_pci_fixup(pdev, (const u16 *)fw->data, fw->size))
 122                 goto release;
 123
 124         pci_lock_rescan_remove();
 125         bus = pdev->bus;
 126         pci_stop_and_remove_bus_device(pdev);
 127         /* the device should come back with the proper
 128          * ProductId. But we have to initiate a rescan.
 129          */
 130         pci_rescan_bus(bus);
 131         pci_unlock_rescan_remove();
 132
 133 release:
 134         release_firmware(fw);
 135 }
 136
 137 static const char *owl_get_eeprom_name(struct pci_dev *pdev)
 138 {
 139         struct device *dev = &pdev->dev;
 140         char *eeprom_name;
 141
 142         dev_dbg(dev, "using auto-generated eeprom filename\n");
 143
 144         eeprom_name = devm_kzalloc(dev, EEPROM_FILENAME_LEN, GFP_KERNEL);
 145         if (!eeprom_name)
 146                 return NULL;
 147
 148         /* this should match the pattern used in ath9k/init.c */
 149         scnprintf(eeprom_name, EEPROM_FILENAME_LEN, "ath9k-eeprom-pci-%s.bin",
 150                   dev_name(dev));
 151
 152         return eeprom_name;
 153 }
 154
 155 static int owl_probe(struct pci_dev *pdev,
 156                      const struct pci_device_id *id)
 157 {
 158         struct owl_ctx *ctx;
 159         const char *eeprom_name;
 160         int err = 0;
 161
 162         if (pcim_enable_device(pdev))
 163                 return -EIO;
 164
 165         pcim_pin_device(pdev);
 166
 167         eeprom_name = owl_get_eeprom_name(pdev);
 168         if (!eeprom_name) {
 169                 dev_err(&pdev->dev, "no eeprom filename found.\n");
 170                 return -ENODEV;
 171         }
 172
 173         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
 174         if (!ctx)
 175                 return -ENOMEM;
 176
 177         init_completion(&ctx->eeprom_load);
 178
 179         pci_set_drvdata(pdev, ctx);
 180         err = request_firmware_nowait(THIS_MODULE, true, eeprom_name,
 181                                       &pdev->dev, GFP_KERNEL, pdev, owl_fw_cb);
 182         if (err)
 183                 dev_err(&pdev->dev, "failed to request caldata (%d).\n", err);
 184
 185         return err;
 186 }
 187
 188 static void owl_remove(struct pci_dev *pdev)
 189 {
 190         struct owl_ctx *ctx = pci_get_drvdata(pdev);
 191
 192         if (ctx) {
 193                 wait_for_completion(&ctx->eeprom_load);
 194                 pci_set_drvdata(pdev, NULL);
 195         }
 196 }
 197
 198 static const struct pci_device_id owl_pci_table[] = {
 199         { PCI_VDEVICE(ATHEROS, 0xff1c) }, /* PCIe */
 200         { PCI_VDEVICE(ATHEROS, 0xff1d) }, /* PCI */
 201         { },
 202 };
 203 MODULE_DEVICE_TABLE(pci, owl_pci_table);
 204
 205 static struct pci_driver owl_driver = {
 206         .name           = KBUILD_MODNAME,
 207         .id_table       = owl_pci_table,
 208         .probe          = owl_probe,
 209         .remove         = owl_remove,
 210 };
 211 module_pci_driver(owl_driver);
 212 MODULE_AUTHOR("Christian Lamparter <chunkeey@gmail.com>");
 213 MODULE_DESCRIPTION("External EEPROM data loader for Atheros AR500X to AR92XX");
 214 MODULE_LICENSE("Dual BSD/GPL");