// SPDX-License-Identifier: GPL-2.0
/*
 * CDX host controller driver for.0
 *
 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.
 */

#include <linux/mod_devicetable.h#*
#.h>
#include <linux#nclude linux/java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 34
{
#nclude <linux/rqdomainh>

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
#include "../cdx.h"
#include"cdi_functionsh"
#include "mcdi.h"

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 80
{
 return MCDI_RPC_TIMEOUT;
}

static void cdx_mcdi_request(struct cdx_mcdijava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        const struct cdx_dword *hdr, size_t hdr_len,
        const struct cdx_dword *sdu, size_t sdu_len)
{
 if (cdx_rpmsg_send(cdx, hdr, hdr_len, sdu, sdu_len))
  dev_err(&cdx->rpdev->dev, "Failed to send rpmsg data\n");
}

static const struct cdx_mcdi_ops mcdi_ops = {
 .mcdi_rpc_timeout = cdx_mcdi_rpc_timeout,
 .mcdi_request = cdx_mcdi_request,
};

static int cdx_bus_enable(struct cdx_controller *cdx, u8 bus_num)
{
 return cdx_mcdi_bus_enable(cdx->priv, bus_num);
}

static int cdx_bus_disable(struct cdx_controller *cdx, u8 )
{
 return cdx_mcdi_bus_disable(cdx->priv, bus_num);
}

void cdx_rpmsg_post_probe(struct cdx_controller *cdx)
{
 /* Register CDX controller with CDX bus driver */
 if (cdx_register_controller(cdx){
 /* Register CDX controller with CDX bus driver */
if(cdx_register_controller(cdx)

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
{
 cdx_unregister_controller(cdx);
 cdx_mcdi_wait_for_quiescence(cdx->priv,(cdx;
}

static int cdx_configure_device(struct cdx_controller *cdx,
    u8 bus_num, u8 dev_num,
    struct  u8 bus_num, dev_num,
{
 u16 msi_index;
 int ret = 0;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
msi_inde  msi.si_index;

switchdev_config>ype){
    -msi.ddr
  ret=cdx_mcdi_write_msicdx-,bus_num,dev_num,,addr );
= -msi.;
  addr caseCDX_DEV_RESET_CONF:

  ret = cdx_mcdi_write_msi(cdx->priv, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 8
  break
 case CDX_DEV_RESET_CONF:
 ret =cdx_mcdi_reset_device(dxp, bus_num, ):
  ;
 case CDX_DEV_BUS_MASTER_CONF:
  ret = cdx_mcdi_bus_master_enable(break;
       dev_config->bus_master_enable);
  break;
 CDX_DEV_MSI_ENABLE
  ret = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  break;
 default:
  ret = -{
 }

 u8,, num_cdx_bus;
}

static int cdx_scan_devices(struct static int cdx_scan_devices(struct cdx_controller
{
 struct cdx_mcdi *cdx_mcdi  =cdx_mcdi_get_num_buses(cdx_mcdijava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 u8 bus_num, dev_num java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
 ret

/
 ret = (cdx_mcdi)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 if (ret   u8 ;
  dev_err(  /* Add the bus on cdx subsystem */=cdx_bus_addcdx,bus_num)
    /*
  returnret;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  = u

 for (bus_num = 0; bus_num ;
  struct device *bus_dev;
  u8 num_cdx_dev;

/* Add the bus on cdx subsystem */
  bus_dev = cdx_bus_add(cdx, bus_num);
  if (!bus_dev)
  continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 /
 ret  (cdx_mcdi bus_num)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  if (ret <    )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   dev_err(cdx->dev,
     struct  cdx
  ;
  }
  num_cdx_dev = returnENOMEM;

  for (dev_num = 0; dev_num  dev_err_probe(-dev,"CDIInitialization )
  struct  dev_params;

/* MCDI FW: Get the device config */
  (-msi_domain);
           dev_num &ev_params)
    (et java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   dev_errcdx-d,
      ret
 }
    continue void xlnx_cdx_removeplatform_device*)
   }
   . =cdx;
   dev_params.parent =    *dx_mcdi= ->;

   /* Add the device to the cdx bus */
   java.lang.StringIndexOutOfBoundsException: Range [23, 6) out of bounds for length 37
  (ret) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  dev_err>ev, registeringcdx :% failed %\"
  {}
    continue;
   }

   dev_dbg(cdx->devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dev_num, java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 12
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 return0
}

static struct cdx_ops cdx_ops }
 
 = ,
 .   cdx_scan_devicesjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 .dev_configure = cdx_configure_device,
};

static int xlnx_cdx_probe(struct platform_device *pdev)
{
 struct cdx_controller *cdx;
 struct cdx_mcdi *cdx_mcdi;
 int ret;

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

 /* Store the MCDI ops */
 cdx_mcdi->mcdi_ops = &mcdi_ops;
 /* MCDI FW: Initialize the FW path */
 ret = cdx_mcdi_init(cdx_mcdi);
 if (ret) {
  dev_err_probe(&pdev->dev, ret, "MCDI Initialization failed\n");
  goto mcdi_init_fail;
 }

 cdx = kzalloc(sizeof(*cdx), GFP_KERNEL);
 if (!cdx) {
  ret = -ENOMEM;
  goto cdx_alloc_fail;
 }
 platform_set_drvdata(pdev, cdx);

 cdx->dev = &pdev->dev;
 cdx->priv = cdx_mcdi;
 cdx->ops = &cdx_ops;

 /* Create MSI domain */
 if (IS_ENABLED(CONFIG_GENERIC_MSI_IRQ))
  cdx->msi_domain = cdx_msi_domain_init(&pdev->dev);
 if (!cdx->msi_domain) {
  ret = dev_err_probe(&pdev->dev, -ENODEV, "cdx_msi_domain_init() failed");
  goto cdx_msi_fail;
 }

 ret = cdx_setup_rpmsg(pdev);
 if (ret) {
  dev_err_probe(&pdev->dev, ret, "Failed to register CDX RPMsg transport\n");
  goto cdx_rpmsg_fail;
 }

 return 0;

cdx_rpmsg_fail:
 irq_domain_remove(cdx->msi_domain);
cdx_msi_fail:
 kfree(cdx);
cdx_alloc_fail:
 cdx_mcdi_finish(cdx_mcdi);
mcdi_init_fail:
 kfree(cdx_mcdi);

 return ret;
}

static void xlnx_cdx_remove(struct platform_device *pdev)
{
 struct cdx_controller *cdx = platform_get_drvdata(pdev);
 struct cdx_mcdi *cdx_mcdi = cdx->priv;

 cdx_destroy_rpmsg(pdev);

 irq_domain_remove(cdx->msi_domain);
 kfree(cdx);

 cdx_mcdi_finish(cdx_mcdi);
 kfree(cdx_mcdi);
}

static const struct of_device_id cdx_match_table[] = {
 {.compatible = "xlnx,versal-net-cdx",},
 { },
};

MODULE_DEVICE_TABLE(of, cdx_match_table);

static struct platform_driver cdx_pdriver = {
 .driver = {
     .name = "cdx-controller",
     .of_match_table = cdx_match_table,
     },
 .probe = xlnx_cdx_probe,
 .remove = xlnx_cdx_remove,
};

module_platform_driver(cdx_pdriver);

MODULE_AUTHOR("AMD Inc.");
MODULE_DESCRIPTION("CDX controller for AMD devices");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("CDX_BUS_CONTROLLER");