iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
Christian Lamparter 2021-09-13 15:40:35 +03:00 committed by Kalle Valo
parent eb3a97a69b
commit ef7bc2a763
1 changed files with 77 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
drivers/net/wireless/ath/ath9k/ath9k_pci_owl_loader.c
View File

@ -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();
}
release:
static void owl_fw_cb(const struct firmware *fw, void *context)
{
struct owl_ctx *ctx = (struct owl_ctx *)context;
complete(&ctx->eeprom_load);
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);
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;
}
ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
if (!ctx)
return -ENOMEM;
init_completion(&ctx->eeprom_load);
pci_set_drvdata(pdev, ctx);
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);