drivers/media/platform/msm/camera/cam_lrme/lrme_hw_mgr/lrme_hw/cam_lrme_hw_dev.c

/* Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <media/cam_req_mgr.h>

#include "cam_subdev.h"
#include "cam_lrme_hw_intf.h"
#include "cam_lrme_hw_core.h"
#include "cam_lrme_hw_soc.h"
#include "cam_lrme_hw_reg.h"
#include "cam_req_mgr_workq.h"
#include "cam_lrme_hw_mgr.h"
#include "cam_mem_mgr_api.h"
#include "cam_smmu_api.h"

static int cam_lrme_hw_dev_util_cdm_acquire(struct cam_lrme_core *lrme_core,
	struct cam_hw_info *lrme_hw)
{
	int rc, i;
	struct cam_cdm_bl_request *cdm_cmd;
	struct cam_cdm_acquire_data cdm_acquire;
	struct cam_lrme_cdm_info *hw_cdm_info;

	hw_cdm_info = kzalloc(sizeof(struct cam_lrme_cdm_info),
		GFP_KERNEL);
	if (!hw_cdm_info) {
		CAM_ERR(CAM_LRME, "No memory for hw_cdm_info");
		return -ENOMEM;
	}

	cdm_cmd = kzalloc((sizeof(struct cam_cdm_bl_request) +
		((CAM_LRME_MAX_HW_ENTRIES - 1) *
		sizeof(struct cam_cdm_bl_cmd))), GFP_KERNEL);
	if (!cdm_cmd) {
		CAM_ERR(CAM_LRME, "No memory for cdm_cmd");
		kfree(hw_cdm_info);
		return -ENOMEM;
	}

	memset(&cdm_acquire, 0, sizeof(cdm_acquire));
	strlcpy(cdm_acquire.identifier, "lrmecdm", sizeof("lrmecdm"));
	cdm_acquire.cell_index = lrme_hw->soc_info.index;
	cdm_acquire.handle = 0;
	cdm_acquire.userdata = hw_cdm_info;
	cdm_acquire.cam_cdm_callback = NULL;
	cdm_acquire.id = CAM_CDM_VIRTUAL;
	cdm_acquire.base_array_cnt = lrme_hw->soc_info.num_reg_map;
	for (i = 0; i < lrme_hw->soc_info.num_reg_map; i++)
		cdm_acquire.base_array[i] = &lrme_hw->soc_info.reg_map[i];

	rc = cam_cdm_acquire(&cdm_acquire);
	if (rc) {
		CAM_ERR(CAM_LRME, "Can't acquire cdm");
		goto error;
	}

	hw_cdm_info->cdm_cmd = cdm_cmd;
	hw_cdm_info->cdm_ops = cdm_acquire.ops;
	hw_cdm_info->cdm_handle = cdm_acquire.handle;

	lrme_core->hw_cdm_info = hw_cdm_info;
	CAM_DBG(CAM_LRME, "cdm acquire done");

	return 0;
error:
	kfree(cdm_cmd);
	kfree(hw_cdm_info);
	return rc;
}

static int cam_lrme_hw_dev_probe(struct platform_device *pdev)
{
	struct cam_hw_info *lrme_hw;
	struct cam_hw_intf lrme_hw_intf;
	struct cam_lrme_core *lrme_core;
	const struct of_device_id *match_dev = NULL;
	struct cam_lrme_hw_info *hw_info;
	int rc, i;

	lrme_hw = kzalloc(sizeof(struct cam_hw_info), GFP_KERNEL);
	if (!lrme_hw) {
		CAM_ERR(CAM_LRME, "No memory to create lrme_hw");
		return -ENOMEM;
	}

	lrme_core = kzalloc(sizeof(struct cam_lrme_core), GFP_KERNEL);
	if (!lrme_core) {
		CAM_ERR(CAM_LRME, "No memory to create lrme_core");
		kfree(lrme_hw);
		return -ENOMEM;
	}

	lrme_hw->core_info = lrme_core;
	lrme_hw->hw_state = CAM_HW_STATE_POWER_DOWN;
	lrme_hw->soc_info.pdev = pdev;
	lrme_hw->soc_info.dev = &pdev->dev;
	lrme_hw->soc_info.dev_name = pdev->name;
	lrme_hw->open_count = 0;
	lrme_core->state = CAM_LRME_CORE_STATE_INIT;

	mutex_init(&lrme_hw->hw_mutex);
	spin_lock_init(&lrme_hw->hw_lock);
	init_completion(&lrme_hw->hw_complete);
	init_completion(&lrme_core->reset_complete);

	rc = cam_req_mgr_workq_create("cam_lrme_hw_worker",
		CAM_LRME_HW_WORKQ_NUM_TASK,
		&lrme_core->work, CRM_WORKQ_USAGE_IRQ, 0);
	if (rc) {
		CAM_ERR(CAM_LRME, "Unable to create a workq, rc=%d", rc);
		goto free_memory;
	}

	for (i = 0; i < CAM_LRME_HW_WORKQ_NUM_TASK; i++)
		lrme_core->work->task.pool[i].payload =
			&lrme_core->work_data[i];

	match_dev = of_match_device(pdev->dev.driver->of_match_table,
		&pdev->dev);
	if (!match_dev || !match_dev->data) {
		CAM_ERR(CAM_LRME, "No Of_match data, %pK", match_dev);
		rc = -EINVAL;
		goto destroy_workqueue;
	}
	hw_info = (struct cam_lrme_hw_info *)match_dev->data;
	lrme_core->hw_info = hw_info;

	rc = cam_lrme_soc_init_resources(&lrme_hw->soc_info,
		cam_lrme_hw_irq, lrme_hw);
	if (rc) {
		CAM_ERR(CAM_LRME, "Failed to init soc, rc=%d", rc);
		goto destroy_workqueue;
	}

	rc = cam_lrme_hw_dev_util_cdm_acquire(lrme_core, lrme_hw);
	if (rc) {
		CAM_ERR(CAM_LRME, "Failed to acquire cdm");
		goto deinit_platform_res;
	}

	rc = cam_smmu_get_handle("lrme", &lrme_core->device_iommu.non_secure);
	if (rc) {
		CAM_ERR(CAM_LRME, "Get iommu handle failed");
		goto release_cdm;
	}

	rc = cam_smmu_ops(lrme_core->device_iommu.non_secure, CAM_SMMU_ATTACH);
	if (rc) {
		CAM_ERR(CAM_LRME, "LRME attach iommu handle failed, rc=%d", rc);
		goto destroy_smmu;
	}

	rc = cam_lrme_hw_start(lrme_hw, NULL, 0);
	if (rc) {
		CAM_ERR(CAM_LRME, "Failed to hw init, rc=%d", rc);
		goto detach_smmu;
	}

	rc = cam_lrme_hw_util_get_caps(lrme_hw, &lrme_core->hw_caps);
	if (rc) {
		CAM_ERR(CAM_LRME, "Failed to get hw caps, rc=%d", rc);
		if (cam_lrme_hw_stop(lrme_hw, NULL, 0))
			CAM_ERR(CAM_LRME, "Failed in hw deinit");
		goto detach_smmu;
	}

	rc = cam_lrme_hw_stop(lrme_hw, NULL, 0);
	if (rc) {
		CAM_ERR(CAM_LRME, "Failed to deinit hw, rc=%d", rc);
		goto detach_smmu;
	}

	lrme_core->hw_idx = lrme_hw->soc_info.index;
	lrme_hw_intf.hw_priv = lrme_hw;
	lrme_hw_intf.hw_idx = lrme_hw->soc_info.index;
	lrme_hw_intf.hw_ops.get_hw_caps = cam_lrme_hw_get_caps;
	lrme_hw_intf.hw_ops.init = NULL;
	lrme_hw_intf.hw_ops.deinit = NULL;
	lrme_hw_intf.hw_ops.reset = cam_lrme_hw_reset;
	lrme_hw_intf.hw_ops.reserve = NULL;
	lrme_hw_intf.hw_ops.release = NULL;
	lrme_hw_intf.hw_ops.start = cam_lrme_hw_start;
	lrme_hw_intf.hw_ops.stop = cam_lrme_hw_stop;
	lrme_hw_intf.hw_ops.read = NULL;
	lrme_hw_intf.hw_ops.write = NULL;
	lrme_hw_intf.hw_ops.process_cmd = cam_lrme_hw_process_cmd;
	lrme_hw_intf.hw_ops.flush = cam_lrme_hw_flush;
	lrme_hw_intf.hw_type = CAM_HW_LRME;

	rc = cam_cdm_get_iommu_handle("lrmecdm", &lrme_core->cdm_iommu);
	if (rc) {
		CAM_ERR(CAM_LRME, "Failed to acquire the CDM iommu handles");
		goto detach_smmu;
	}

	rc = cam_lrme_mgr_register_device(&lrme_hw_intf,
		&lrme_core->device_iommu,
		&lrme_core->cdm_iommu);
	if (rc) {
		CAM_ERR(CAM_LRME, "Failed to register device");
		goto detach_smmu;
	}

	platform_set_drvdata(pdev, lrme_hw);
	CAM_DBG(CAM_LRME, "LRME-%d probe successful", lrme_hw_intf.hw_idx);

	return rc;

detach_smmu:
	cam_smmu_ops(lrme_core->device_iommu.non_secure, CAM_SMMU_DETACH);
destroy_smmu:
	cam_smmu_destroy_handle(lrme_core->device_iommu.non_secure);
release_cdm:
	cam_cdm_release(lrme_core->hw_cdm_info->cdm_handle);
	kfree(lrme_core->hw_cdm_info->cdm_cmd);
	kfree(lrme_core->hw_cdm_info);
deinit_platform_res:
	if (cam_lrme_soc_deinit_resources(&lrme_hw->soc_info))
		CAM_ERR(CAM_LRME, "Failed in soc deinit");
	mutex_destroy(&lrme_hw->hw_mutex);
destroy_workqueue:
	cam_req_mgr_workq_destroy(&lrme_core->work);
free_memory:
	mutex_destroy(&lrme_hw->hw_mutex);
	kfree(lrme_hw);
	kfree(lrme_core);

	return rc;
}

static int cam_lrme_hw_dev_remove(struct platform_device *pdev)
{
	int rc = 0;
	struct cam_hw_info *lrme_hw;
	struct cam_lrme_core *lrme_core;

	lrme_hw = platform_get_drvdata(pdev);
	if (!lrme_hw) {
		CAM_ERR(CAM_LRME, "Invalid lrme_hw from fd_hw_intf");
		rc = -ENODEV;
		goto deinit_platform_res;
	}

	lrme_core = (struct cam_lrme_core *)lrme_hw->core_info;
	if (!lrme_core) {
		CAM_ERR(CAM_LRME, "Invalid lrme_core from fd_hw");
		rc = -EINVAL;
		goto deinit_platform_res;
	}

	cam_smmu_ops(lrme_core->device_iommu.non_secure, CAM_SMMU_DETACH);
	cam_smmu_destroy_handle(lrme_core->device_iommu.non_secure);
	cam_cdm_release(lrme_core->hw_cdm_info->cdm_handle);
	cam_lrme_mgr_deregister_device(lrme_core->hw_idx);

	kfree(lrme_core->hw_cdm_info->cdm_cmd);
	kfree(lrme_core->hw_cdm_info);
	kfree(lrme_core);

deinit_platform_res:
	rc = cam_lrme_soc_deinit_resources(&lrme_hw->soc_info);
	if (rc)
		CAM_ERR(CAM_LRME, "Error in LRME soc deinit, rc=%d", rc);

	mutex_destroy(&lrme_hw->hw_mutex);
	kfree(lrme_hw);

	return rc;
}

static const struct of_device_id cam_lrme_hw_dt_match[] = {
	{
		.compatible = "qcom,lrme",
		.data = &cam_lrme10_hw_info,
	},
	{}
};

MODULE_DEVICE_TABLE(of, cam_lrme_hw_dt_match);

static struct platform_driver cam_lrme_hw_driver = {
	.probe = cam_lrme_hw_dev_probe,
	.remove = cam_lrme_hw_dev_remove,
	.driver = {
		.name = "cam_lrme_hw",
		.owner = THIS_MODULE,
		.of_match_table = cam_lrme_hw_dt_match,
	},
};

static int __init cam_lrme_hw_init_module(void)
{
	return platform_driver_register(&cam_lrme_hw_driver);
}

static void __exit cam_lrme_hw_exit_module(void)
{
	platform_driver_unregister(&cam_lrme_hw_driver);
}

module_init(cam_lrme_hw_init_module);
module_exit(cam_lrme_hw_exit_module);
MODULE_DESCRIPTION("CAM LRME HW driver");
MODULE_LICENSE("GPL v2");