// SPDX-License-Identifier: BSD-3-Clause-Clear
/*
 * Copyright (c) 2019-2021 The Linux Foundation. All rights reserved.
 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 */

#include <linux/pci.h>

#include "../pci.h"
#include "pci.h"
#include "../core.h"
#include "../hif.h"
#include "../mhi.h"
#include "hw.h"
#include "../hal.h"
#include "dp.h"
#include "core.h"
#include "hal.h"

#define QCN9274_DEVICE_ID		0x1109
#define WCN7850_DEVICE_ID		0x1107
#define QCC2072_DEVICE_ID		0x1112

#define ATH12K_PCI_W7_SOC_HW_VERSION_1	1
#define ATH12K_PCI_W7_SOC_HW_VERSION_2	2

#define TCSR_SOC_HW_VERSION		0x1B00000
#define TCSR_SOC_HW_VERSION_MAJOR_MASK	GENMASK(11, 8)
#define TCSR_SOC_HW_VERSION_MINOR_MASK	GENMASK(7, 4)

#define WINDOW_REG_ADDRESS		0x310c
#define WINDOW_REG_ADDRESS_QCC2072	0x3278

static const struct pci_device_id ath12k_wifi7_pci_id_table[] = {
	{ PCI_VDEVICE(QCOM, QCN9274_DEVICE_ID) },
	{ PCI_VDEVICE(QCOM, WCN7850_DEVICE_ID) },
	{ PCI_VDEVICE(QCOM, QCC2072_DEVICE_ID) },
	{}
};

MODULE_DEVICE_TABLE(pci, ath12k_wifi7_pci_id_table);

/* TODO: revisit IRQ mapping for new SRNG's */
static const struct ath12k_msi_config ath12k_wifi7_msi_config[] = {
	{
		.total_vectors = 16,
		.total_users = 3,
		.users = (struct ath12k_msi_user[]) {
			{ .name = "MHI", .num_vectors = 3, .base_vector = 0 },
			{ .name = "CE", .num_vectors = 5, .base_vector = 3 },
			{ .name = "DP", .num_vectors = 8, .base_vector = 8 },
		},
	},
};

static const struct ath12k_pci_ops ath12k_wifi7_pci_ops_qcn9274 = {
	.wakeup = NULL,
	.release = NULL,
};

static int ath12k_wifi7_pci_bus_wake_up(struct ath12k_base *ab)
{
	struct ath12k_pci *ab_pci = ath12k_pci_priv(ab);

	return mhi_device_get_sync(ab_pci->mhi_ctrl->mhi_dev);
}

static void ath12k_wifi7_pci_bus_release(struct ath12k_base *ab)
{
	struct ath12k_pci *ab_pci = ath12k_pci_priv(ab);

	mhi_device_put(ab_pci->mhi_ctrl->mhi_dev);
}

static const struct ath12k_pci_ops ath12k_wifi7_pci_ops_wcn7850 = {
	.wakeup = ath12k_wifi7_pci_bus_wake_up,
	.release = ath12k_wifi7_pci_bus_release,
};

static
void ath12k_wifi7_pci_read_hw_version(struct ath12k_base *ab,
				      u32 *major, u32 *minor)
{
	u32 soc_hw_version;

	soc_hw_version = ath12k_pci_read32(ab, TCSR_SOC_HW_VERSION);
	*major = u32_get_bits(soc_hw_version, TCSR_SOC_HW_VERSION_MAJOR_MASK);
	*minor = u32_get_bits(soc_hw_version, TCSR_SOC_HW_VERSION_MINOR_MASK);
}

static int ath12k_wifi7_pci_probe(struct pci_dev *pdev,
				  const struct pci_device_id *pci_dev)
{
	u32 soc_hw_version_major, soc_hw_version_minor;
	struct ath12k_pci *ab_pci;
	struct ath12k_base *ab;
	int ret;

	ab = pci_get_drvdata(pdev);
	if (!ab)
		return -EINVAL;

	ab_pci = ath12k_pci_priv(ab);
	if (!ab_pci)
		return -EINVAL;

	switch (pci_dev->device) {
	case QCN9274_DEVICE_ID:
		ab_pci->msi_config = &ath12k_wifi7_msi_config[0];
		ab->static_window_map = true;
		ab_pci->pci_ops = &ath12k_wifi7_pci_ops_qcn9274;
		/*
		 * init window reg addr before reading hardware version
		 * as it will be used there
		 */
		ab_pci->window_reg_addr = WINDOW_REG_ADDRESS;
		ath12k_wifi7_pci_read_hw_version(ab, &soc_hw_version_major,
						 &soc_hw_version_minor);
		ab->target_mem_mode = ath12k_core_get_memory_mode(ab);
		switch (soc_hw_version_major) {
		case ATH12K_PCI_W7_SOC_HW_VERSION_2:
			ab->hw_rev = ATH12K_HW_QCN9274_HW20;
			break;
		case ATH12K_PCI_W7_SOC_HW_VERSION_1:
			ab->hw_rev = ATH12K_HW_QCN9274_HW10;
			break;
		default:
			dev_err(&pdev->dev,
				"Unknown hardware version found for QCN9274: 0x%x\n",
				soc_hw_version_major);
			return -EOPNOTSUPP;
		}
		break;
	case WCN7850_DEVICE_ID:
		ab->id.bdf_search = ATH12K_BDF_SEARCH_BUS_AND_BOARD;
		ab_pci->msi_config = &ath12k_wifi7_msi_config[0];
		ab->static_window_map = false;
		ab_pci->pci_ops = &ath12k_wifi7_pci_ops_wcn7850;
		/*
		 * init window reg addr before reading hardware version
		 * as it will be used there
		 */
		ab_pci->window_reg_addr = WINDOW_REG_ADDRESS;
		ath12k_wifi7_pci_read_hw_version(ab, &soc_hw_version_major,
						 &soc_hw_version_minor);
		ab->target_mem_mode = ATH12K_QMI_MEMORY_MODE_DEFAULT;
		switch (soc_hw_version_major) {
		case ATH12K_PCI_W7_SOC_HW_VERSION_2:
			ab->hw_rev = ATH12K_HW_WCN7850_HW20;
			break;
		default:
			dev_err(&pdev->dev,
				"Unknown hardware version found for WCN7850: 0x%x\n",
				soc_hw_version_major);
			return -EOPNOTSUPP;
		}
		break;
	case QCC2072_DEVICE_ID:
		ab->id.bdf_search = ATH12K_BDF_SEARCH_BUS_AND_BOARD;
		ab_pci->msi_config = &ath12k_wifi7_msi_config[0];
		ab->static_window_map = false;
		ab_pci->pci_ops = &ath12k_wifi7_pci_ops_wcn7850;
		ab_pci->window_reg_addr = WINDOW_REG_ADDRESS_QCC2072;
		ab->target_mem_mode = ATH12K_QMI_MEMORY_MODE_DEFAULT;
		/* there is only one version till now */
		ab->hw_rev = ATH12K_HW_QCC2072_HW10;
		break;
	default:
		dev_err(&pdev->dev, "Unknown Wi-Fi 7 PCI device found: 0x%x\n",
			pci_dev->device);
		return -EOPNOTSUPP;
	}

	ret = ath12k_wifi7_hw_init(ab);
	if (ret) {
		dev_err(&pdev->dev, "WiFi-7 hw_init for PCI failed: %d\n", ret);
		return ret;
	}

	return 0;
}

static const struct ath12k_pci_reg_base ath12k_wifi7_reg_base = {
	.umac_base = HAL_SEQ_WCSS_UMAC_OFFSET,
	.ce_reg_base = HAL_CE_WFSS_CE_REG_BASE,
};

static struct ath12k_pci_driver ath12k_wifi7_pci_driver = {
	.name = "ath12k_wifi7_pci",
	.id_table = ath12k_wifi7_pci_id_table,
	.ops.probe = ath12k_wifi7_pci_probe,
	.reg_base = &ath12k_wifi7_reg_base,
	.ops.arch_init = ath12k_wifi7_arch_init,
	.ops.arch_deinit = ath12k_wifi7_arch_deinit,
};

int ath12k_wifi7_pci_init(void)
{
	int ret;

	ret = ath12k_pci_register_driver(ATH12K_DEVICE_FAMILY_WIFI7,
					 &ath12k_wifi7_pci_driver);
	if (ret) {
		pr_err("Failed to register ath12k Wi-Fi 7 driver: %d\n",
		       ret);
		return ret;
	}

	return 0;
}

void ath12k_wifi7_pci_exit(void)
{
	ath12k_pci_unregister_driver(ATH12K_DEVICE_FAMILY_WIFI7);
}