// SPDX-License-Identifier: GPL-2.0
// Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.

#include <linux/delay.h>
#include <linux/iopoll.h>

#include "hinic3_hw_cfg.h"
#include "hinic3_hwdev.h"
#include "hinic3_lld.h"
#include "hinic3_mgmt.h"

#define HINIC3_VF_PCI_CFG_REG_BAR  0
#define HINIC3_PCI_INTR_REG_BAR    2
#define HINIC3_PCI_DB_BAR          4

#define HINIC3_EVENT_POLL_SLEEP_US   1000
#define HINIC3_EVENT_POLL_TIMEOUT_US 10000000

static struct hinic3_adev_device {
 const char *name;
} hinic3_adev_devices[HINIC3_SERVICE_T_MAX] = {
 [HINIC3_SERVICE_T_NIC] = {
  .name = "nic",
 },
};

static bool hinic3_adev_svc_supported(struct hinic3_hwdev *hwdev,
          enum hinic3_service_type svc_type)
{
 switch (svc_type) {
 case HINIC3_SERVICE_T_NIC:
  return hinic3_support_nic(hwdev);
 default:
  break;
 }

 return false;
}

static void hinic3_comm_adev_release(struct device *dev)
{
 struct hinic3_adev *hadev = container_of(dev, struct hinic3_adev,
       adev.dev);

 kfree(hadev);
}

static struct hinic3_adev *hinic3_add_one_adev(struct hinic3_hwdev *hwdev,
            enum hinic3_service_type svc_type)
{
 struct hinic3_adev *hadev;
 const char *svc_name;
 int ret;

 hadev = kzalloc(sizeof(*hadev), GFP_KERNEL);
 if (!hadev)
  return NULL;

 svc_name = hinic3_adev_devices[svc_type].name;
 hadev->adev.name = svc_name;
 hadev->adev.id = hwdev->dev_id;
 hadev->adev.dev.parent = hwdev->dev;
 hadev->adev.dev.release = hinic3_comm_adev_release;
 hadev->svc_type = svc_type;
 hadev->hwdev = hwdev;

 ret = auxiliary_device_init(&hadev->adev);
 if (ret) {
  dev_err(hwdev->dev, "failed init adev %s %u\n",
   svc_name, hwdev->dev_id);
  kfree(hadev);
  return NULL;
 }

 ret = auxiliary_device_add(&hadev->adev);
 if (ret) {
  dev_err(hwdev->dev, "failed to add adev %s %u\n",
   svc_name, hwdev->dev_id);
  auxiliary_device_uninit(&hadev->adev);
  return NULL;
 }

 return hadev;
}

static void hinic3_del_one_adev(struct hinic3_hwdev *hwdev,
    enum hinic3_service_type svc_type)
{
 struct hinic3_pcidev *pci_adapter = hwdev->adapter;
 struct hinic3_adev *hadev;
 int timeout;
 bool state;

 timeout = read_poll_timeout(test_and_set_bit, state, !state,
        HINIC3_EVENT_POLL_SLEEP_US,
        HINIC3_EVENT_POLL_TIMEOUT_US,
        false, svc_type, &pci_adapter->state);

 hadev = pci_adapter->hadev[svc_type];
 auxiliary_device_delete(&hadev->adev);
 auxiliary_device_uninit(&hadev->adev);
 pci_adapter->hadev[svc_type] = NULL;
 if (!timeout)
  clear_bit(svc_type, &pci_adapter->state);
}

static int hinic3_attach_aux_devices(struct hinic3_hwdev *hwdev)
{
 struct hinic3_pcidev *pci_adapter = hwdev->adapter;
 enum hinic3_service_type svc_type;

 mutex_lock(&pci_adapter->pdev_mutex);

 for (svc_type = 0; svc_type < HINIC3_SERVICE_T_MAX; svc_type++) {
  if (!hinic3_adev_svc_supported(hwdev, svc_type))
   continue;

  pci_adapter->hadev[svc_type] = hinic3_add_one_adev(hwdev,
           svc_type);
  if (!pci_adapter->hadev[svc_type])
   goto err_del_adevs;
 }
 mutex_unlock(&pci_adapter->pdev_mutex);
 return 0;

err_del_adevs:
 while (svc_type > 0) {
  svc_type--;
  if (pci_adapter->hadev[svc_type]) {
   hinic3_del_one_adev(hwdev, svc_type);
   pci_adapter->hadev[svc_type] = NULL;
  }
 }
 mutex_unlock(&pci_adapter->pdev_mutex);
 return -ENOMEM;
}

static void hinic3_detach_aux_devices(struct hinic3_hwdev *hwdev)
{
 struct hinic3_pcidev *pci_adapter = hwdev->adapter;
 int i;

 mutex_lock(&pci_adapter->pdev_mutex);
 for (i = 0; i < ARRAY_SIZE(hinic3_adev_devices); i++) {
  if (pci_adapter->hadev[i])
   hinic3_del_one_adev(hwdev, i);
 }
 mutex_unlock(&pci_adapter->pdev_mutex);
}

struct hinic3_hwdev *hinic3_adev_get_hwdev(struct auxiliary_device *adev)
{
 struct hinic3_adev *hadev;

 hadev = container_of(adev, struct hinic3_adev, adev);
 return hadev->hwdev;
}

void hinic3_adev_event_register(struct auxiliary_device *adev,
    void (*event_handler)(struct auxiliary_device *adev,
            struct hinic3_event_info *event))
{
 struct hinic3_adev *hadev;

 hadev = container_of(adev, struct hinic3_adev, adev);
 hadev->event = event_handler;
}

void hinic3_adev_event_unregister(struct auxiliary_device *adev)
{
 struct hinic3_adev *hadev;

 hadev = container_of(adev, struct hinic3_adev, adev);
 hadev->event = NULL;
}

static int hinic3_mapping_bar(struct pci_dev *pdev,
         struct hinic3_pcidev *pci_adapter)
{
 pci_adapter->cfg_reg_base = pci_ioremap_bar(pdev,
          HINIC3_VF_PCI_CFG_REG_BAR);
 if (!pci_adapter->cfg_reg_base) {
  dev_err(&pdev->dev, "Failed to map configuration regs\n");
  return -ENOMEM;
 }

 pci_adapter->intr_reg_base = pci_ioremap_bar(pdev,
           HINIC3_PCI_INTR_REG_BAR);
 if (!pci_adapter->intr_reg_base) {
  dev_err(&pdev->dev, "Failed to map interrupt regs\n");
  goto err_unmap_cfg_reg_base;
 }

 pci_adapter->db_base_phy = pci_resource_start(pdev, HINIC3_PCI_DB_BAR);
 pci_adapter->db_dwqe_len = pci_resource_len(pdev, HINIC3_PCI_DB_BAR);
 pci_adapter->db_base = pci_ioremap_bar(pdev, HINIC3_PCI_DB_BAR);
 if (!pci_adapter->db_base) {
  dev_err(&pdev->dev, "Failed to map doorbell regs\n");
  goto err_unmap_intr_reg_base;
 }

 return 0;

err_unmap_intr_reg_base:
 iounmap(pci_adapter->intr_reg_base);

err_unmap_cfg_reg_base:
 iounmap(pci_adapter->cfg_reg_base);

 return -ENOMEM;
}

static void hinic3_unmapping_bar(struct hinic3_pcidev *pci_adapter)
{
 iounmap(pci_adapter->db_base);
 iounmap(pci_adapter->intr_reg_base);
 iounmap(pci_adapter->cfg_reg_base);
}

static int hinic3_pci_init(struct pci_dev *pdev)
{
 struct hinic3_pcidev *pci_adapter;
 int err;

 pci_adapter = kzalloc(sizeof(*pci_adapter), GFP_KERNEL);
 if (!pci_adapter)
  return -ENOMEM;

 pci_adapter->pdev = pdev;
 mutex_init(&pci_adapter->pdev_mutex);

 pci_set_drvdata(pdev, pci_adapter);

 err = pci_enable_device(pdev);
 if (err) {
  dev_err(&pdev->dev, "Failed to enable PCI device\n");
  goto err_free_pci_adapter;
 }

 err = pci_request_regions(pdev, HINIC3_NIC_DRV_NAME);
 if (err) {
  dev_err(&pdev->dev, "Failed to request regions\n");
  goto err_disable_device;
 }

 pci_set_master(pdev);

 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
 if (err) {
  dev_err(&pdev->dev, "Failed to set DMA mask\n");
  goto err_release_regions;
 }

 return 0;

err_release_regions:
 pci_clear_master(pdev);
 pci_release_regions(pdev);

err_disable_device:
 pci_disable_device(pdev);

err_free_pci_adapter:
 pci_set_drvdata(pdev, NULL);
 mutex_destroy(&pci_adapter->pdev_mutex);
 kfree(pci_adapter);

 return err;
}

static void hinic3_pci_uninit(struct pci_dev *pdev)
{
 struct hinic3_pcidev *pci_adapter = pci_get_drvdata(pdev);

 pci_clear_master(pdev);
 pci_release_regions(pdev);
 pci_disable_device(pdev);
 pci_set_drvdata(pdev, NULL);
 mutex_destroy(&pci_adapter->pdev_mutex);
 kfree(pci_adapter);
}

static int hinic3_func_init(struct pci_dev *pdev,
       struct hinic3_pcidev *pci_adapter)
{
 int err;

 err = hinic3_init_hwdev(pdev);
 if (err) {
  dev_err(&pdev->dev, "Failed to initialize hardware device\n");
  return err;
 }

 err = hinic3_attach_aux_devices(pci_adapter->hwdev);
 if (err)
  goto err_free_hwdev;

 return 0;

err_free_hwdev:
 hinic3_free_hwdev(pci_adapter->hwdev);

 return err;
}

static void hinic3_func_uninit(struct pci_dev *pdev)
{
 struct hinic3_pcidev *pci_adapter = pci_get_drvdata(pdev);

 hinic3_detach_aux_devices(pci_adapter->hwdev);
 hinic3_free_hwdev(pci_adapter->hwdev);
}

static int hinic3_probe_func(struct hinic3_pcidev *pci_adapter)
{
 struct pci_dev *pdev = pci_adapter->pdev;
 int err;

 err = hinic3_mapping_bar(pdev, pci_adapter);
 if (err) {
  dev_err(&pdev->dev, "Failed to map bar\n");
  goto err_out;
 }

 err = hinic3_func_init(pdev, pci_adapter);
 if (err)
  goto err_unmap_bar;

 return 0;

err_unmap_bar:
 hinic3_unmapping_bar(pci_adapter);

err_out:
 dev_err(&pdev->dev, "PCIe device probe function failed\n");
 return err;
}

static void hinic3_remove_func(struct hinic3_pcidev *pci_adapter)
{
 struct pci_dev *pdev = pci_adapter->pdev;

 hinic3_func_uninit(pdev);
 hinic3_unmapping_bar(pci_adapter);
}

static int hinic3_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
 struct hinic3_pcidev *pci_adapter;
 int err;

 err = hinic3_pci_init(pdev);
 if (err)
  goto err_out;

 pci_adapter = pci_get_drvdata(pdev);
 err = hinic3_probe_func(pci_adapter);
 if (err)
  goto err_uninit_pci;

 return 0;

err_uninit_pci:
 hinic3_pci_uninit(pdev);

err_out:
 dev_err(&pdev->dev, "PCIe device probe failed\n");
 return err;
}

static void hinic3_remove(struct pci_dev *pdev)
{
 struct hinic3_pcidev *pci_adapter = pci_get_drvdata(pdev);

 hinic3_remove_func(pci_adapter);
 hinic3_pci_uninit(pdev);
}

static const struct pci_device_id hinic3_pci_table[] = {
 /* Completed by later submission due to LoC limit. */
 {0, 0}

};

MODULE_DEVICE_TABLE(pci, hinic3_pci_table);

static void hinic3_shutdown(struct pci_dev *pdev)
{
 struct hinic3_pcidev *pci_adapter = pci_get_drvdata(pdev);

 pci_disable_device(pdev);

 if (pci_adapter)
  hinic3_set_api_stop(pci_adapter->hwdev);
}

static struct pci_driver hinic3_driver = {
 .name            = HINIC3_NIC_DRV_NAME,
 .id_table        = hinic3_pci_table,
 .probe           = hinic3_probe,
 .remove          = hinic3_remove,
 .shutdown        = hinic3_shutdown,
 .sriov_configure = pci_sriov_configure_simple
};

int hinic3_lld_init(void)
{
 return pci_register_driver(&hinic3_driver);
}

void hinic3_lld_exit(void)
{
 pci_unregister_driver(&hinic3_driver);
}