ath9k: owl-loader: fetch pci init values through nvmem

extends the owl loader to fetch important pci initialization
values - which are stored together with the calibration data -
through the nvmem subsystem.

This allows for much faster WIFI/ath9k initializations on devices
that do not require to perform any post-processing (like XOR'ing/
reversal or unpacking)... than the current way through the
firmware_request which involves the filesystem/userspace.

Signed-off-by: Christian Lamparter <chunkeey@gmail.com>
Signed-off-by: Kalle Valo <kvalo@codeaurora.org>
Link: https://lore.kernel.org/r/bc79ba1c6f6435000577bf1e5f4d7ebe18a8df97.1630157099.git.chunkeey@gmail.com

diff --git a/drivers/net/wireless/ath/ath9k/ath9k_pci_owl_loader.c b/drivers/net/wireless/ath/ath9k/ath9k_pci_owl_loader.c
index 56d1a7764b9f8746819898a2247a9bf83c3da3c2..708c8969b503ab62848ecf19cb98d345b53dff09 100644 (file)
--- a/drivers/net/wireless/ath/ath9k/ath9k_pci_owl_loader.c
+++ b/drivers/net/wireless/ath/ath9k/ath9k_pci_owl_loader.c
@@ -19,9 +19,14 @@
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/ath9k_platform.h>
+#include <linux/nvmem-consumer.h>
+#include <linux/workqueue.h>
 
 struct owl_ctx {
+       struct pci_dev *pdev;
        struct completion eeprom_load;
+       struct work_struct work;
+       struct nvmem_cell *cell;
 };
 
 #define EEPROM_FILENAME_LEN 100
@@ -42,6 +47,12 @@ static int ath9k_pci_fixup(struct pci_dev *pdev, const u16 *cal_data,
        u32 bar0;
        bool swap_needed = false;
 
+       /* also note that we are doing *u16 operations on the file */
+       if (cal_len > 4096 || cal_len < 0x200 || (cal_len & 1) == 1) {
+               dev_err(&pdev->dev, "eeprom has an invalid size.\n");
+               return -EINVAL;
+       }
+
        if (*cal_data != AR5416_EEPROM_MAGIC) {
                if (*cal_data != swab16(AR5416_EEPROM_MAGIC)) {
                        dev_err(&pdev->dev, "invalid calibration data\n");
@@ -99,38 +110,31 @@ static int ath9k_pci_fixup(struct pci_dev *pdev, const u16 *cal_data,
        return 0;
 }
 
-static void owl_fw_cb(const struct firmware *fw, void *context)
+static void owl_rescan(struct pci_dev *pdev)
 {
-       struct pci_dev *pdev = (struct pci_dev *)context;
-       struct owl_ctx *ctx = (struct owl_ctx *)pci_get_drvdata(pdev);
-       struct pci_bus *bus;
-
-       complete(&ctx->eeprom_load);
-
-       if (!fw) {
-               dev_err(&pdev->dev, "no eeprom data received.\n");
-               goto release;
-       }
-
-       /* also note that we are doing *u16 operations on the file */
-       if (fw->size > 4096 || fw->size < 0x200 || (fw->size & 1) == 1) {
-               dev_err(&pdev->dev, "eeprom file has an invalid size.\n");
-               goto release;
-       }
-
-       if (ath9k_pci_fixup(pdev, (const u16 *)fw->data, fw->size))
-               goto release;
+       struct pci_bus *bus = pdev->bus;
 
        pci_lock_rescan_remove();
-       bus = pdev->bus;
        pci_stop_and_remove_bus_device(pdev);
        /* the device should come back with the proper
         * ProductId. But we have to initiate a rescan.
         */
        pci_rescan_bus(bus);
        pci_unlock_rescan_remove();
+}
+
+static void owl_fw_cb(const struct firmware *fw, void *context)
+{
+       struct owl_ctx *ctx = (struct owl_ctx *)context;
+
+       complete(&ctx->eeprom_load);
 
-release:
+       if (fw) {
+               ath9k_pci_fixup(ctx->pdev, (const u16 *)fw->data, fw->size);
+               owl_rescan(ctx->pdev);
+       } else {
+               dev_err(&ctx->pdev->dev, "no eeprom data received.\n");
+       }
        release_firmware(fw);
 }
 
@@ -152,6 +156,43 @@ static const char *owl_get_eeprom_name(struct pci_dev *pdev)
        return eeprom_name;
 }
 
+static void owl_nvmem_work(struct work_struct *work)
+{
+       struct owl_ctx *ctx = container_of(work, struct owl_ctx, work);
+       void *buf;
+       size_t len;
+
+       complete(&ctx->eeprom_load);
+
+       buf = nvmem_cell_read(ctx->cell, &len);
+       if (!IS_ERR(buf)) {
+               ath9k_pci_fixup(ctx->pdev, buf, len);
+               kfree(buf);
+               owl_rescan(ctx->pdev);
+       } else {
+               dev_err(&ctx->pdev->dev, "no nvmem data received.\n");
+       }
+}
+
+static int owl_nvmem_probe(struct owl_ctx *ctx)
+{
+       int err;
+
+       ctx->cell = devm_nvmem_cell_get(&ctx->pdev->dev, "calibration");
+       if (IS_ERR(ctx->cell)) {
+               err = PTR_ERR(ctx->cell);
+               if (err == -ENOENT || err == -EOPNOTSUPP)
+                       return 1; /* not present, try firmware_request */
+
+               return err;
+       }
+
+       INIT_WORK(&ctx->work, owl_nvmem_work);
+       schedule_work(&ctx->work);
+
+       return 0;
+}
+
 static int owl_probe(struct pci_dev *pdev,
                     const struct pci_device_id *id)
 {
@@ -164,21 +205,27 @@ static int owl_probe(struct pci_dev *pdev,
 
        pcim_pin_device(pdev);
 
-       eeprom_name = owl_get_eeprom_name(pdev);
-       if (!eeprom_name) {
-               dev_err(&pdev->dev, "no eeprom filename found.\n");
-               return -ENODEV;
-       }
-
        ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
        if (!ctx)
                return -ENOMEM;
 
        init_completion(&ctx->eeprom_load);
+       ctx->pdev = pdev;
 
        pci_set_drvdata(pdev, ctx);
+
+       err = owl_nvmem_probe(ctx);
+       if (err <= 0)
+               return err;
+
+       eeprom_name = owl_get_eeprom_name(pdev);
+       if (!eeprom_name) {
+               dev_err(&pdev->dev, "no eeprom filename found.\n");
+               return -ENODEV;
+       }
+
        err = request_firmware_nowait(THIS_MODULE, true, eeprom_name,
-                                     &pdev->dev, GFP_KERNEL, pdev, owl_fw_cb);
+                                     &pdev->dev, GFP_KERNEL, ctx, owl_fw_cb);
        if (err)
                dev_err(&pdev->dev, "failed to request caldata (%d).\n", err);