samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Koodi Ongelmat Pull-pyynnöt Actions Paketit Projektit Julkaisut Wiki Toiminta

Merge "msm: camera: isp: Add code for SFE HW" into camera-kernel.lnx.4.0

Selaa lähdekoodia
This commit is contained in:
Camera Software Integration
2020-09-10 13:28:42 -07:00
committed by Gerrit - the friendly Code Review server
vanhempi 876c0a9b3a 0934fe0103
commit 59c745ae8c
11 muutettua tiedostoa jossa 951 lisäystä ja 0 poistoa
Download Patch File Download Diff File Expand all files Collapse all files

5
drivers/Makefile
Näytä tiedosto

@@ -97,6 +97,11 @@ camera-$(CONFIG_SPECTRA_ISP) += \
cam_isp/cam_isp_dev.o \
cam_isp/cam_isp_context.o
camera-$(CONFIG_SPECTRA_SFE) += \
cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_soc.o \
cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_dev.o \
cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_core.o
camera-$(CONFIG_SPECTRA_ICP) += \
cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.o \
cam_icp/icp_hw/ipe_hw/ipe_dev.o \

1
drivers/cam_isp/isp_hw_mgr/isp_hw/include/cam_isp_hw.h
Näytä tiedosto

@@ -49,6 +49,7 @@ enum cam_isp_hw_type {
CAM_ISP_HW_TYPE_TFE,
CAM_ISP_HW_TYPE_TFE_CSID,
CAM_ISP_HW_TYPE_TPG,
CAM_ISP_HW_TYPE_SFE,
CAM_ISP_HW_TYPE_MAX,
};

157
drivers/cam_isp/isp_hw_mgr/isp_hw/include/cam_sfe_hw_intf.h Normal file
Näytä tiedosto

@@ -0,0 +1,157 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_SFE_HW_INTF_H_
#define _CAM_SFE_HW_INTF_H_
#include "cam_isp_hw.h"
#define CAM_SFE_HW_NUM_MAX 2
#define SFE_CORE_BASE_IDX 0
enum cam_isp_hw_sfe_in {
CAM_ISP_HW_SFE_IN_PIX,
CAM_ISP_HW_SFE_IN_RD0,
CAM_ISP_HW_SFE_IN_RD1,
CAM_ISP_HW_SFE_IN_RD2,
CAM_ISP_HW_SFE_IN_RDI0,
CAM_ISP_HW_SFE_IN_RDI1,
CAM_ISP_HW_SFE_IN_RDI2,
CAM_ISP_HW_SFE_IN_RDI3,
CAM_ISP_HW_SFE_IN_RDI4,
CAM_ISP_HW_SFE_IN_MAX,
};
enum cam_sfe_hw_irq_status {
CAM_SFE_IRQ_STATUS_SUCCESS,
CAM_SFE_IRQ_STATUS_ERR,
CAM_SFE_IRQ_STATUS_OVERFLOW,
CAM_SFE_IRQ_STATUS_VIOLATION,
CAM_SFE_IRQ_STATUS_MAX,
};
/*
* struct cam_sfe_hw_get_hw_cap:
*
* @reserved_1: reserved
* @reserved_2: reserved
* @reserved_3: reserved
* @reserved_4: reserved
*/
struct cam_sfe_hw_get_hw_cap {
uint32_t reserved_1;
uint32_t reserved_2;
uint32_t reserved_3;
uint32_t reserved_4;
};
/*
* struct cam_sfe_hw_vfe_bus_rd_acquire_args:
*
* @rsrc_node: Pointer to Resource Node object, filled if acquire
* is successful
* @res_id: Unique Identity of port to associate with this
* resource.
* @is_dual: Flag to indicate dual SFE usecase
* @cdm_ops: CDM operations
* @unpacket_fmt: Unpacker format for read engine
* @is_offline: Flag to indicate offline usecase
*/
struct cam_sfe_hw_sfe_bus_rd_acquire_args {
struct cam_isp_resource_node *rsrc_node;
uint32_t res_id;
uint32_t is_dual;
struct cam_cdm_utils_ops *cdm_ops;
uint32_t unpacker_fmt;
bool is_offline;
};
/*
* struct cam_sfe_hw_sfe_bus_in_acquire_args:
*
* @rsrc_node: Pointer to Resource Node object, filled if acquire
* is successful
* @res_id: Unique Identity of port to associate with this
* resource.
* @cdm_ops: CDM operations
* @is_dual: Dual mode usecase
* @sync_mode: If in dual mode, indicates master/slave
* @in_port: in port info
* @is_fe_enabled: Flag to indicate if FE is enabled
* @is_offline: Flag to indicate Offline IFE
*/
struct cam_sfe_hw_sfe_in_acquire_args {
struct cam_isp_resource_node *rsrc_node;
uint32_t res_id;
struct cam_cdm_utils_ops *cdm_ops;
uint32_t is_dual;
enum cam_isp_hw_sync_mode sync_mode;
struct cam_isp_in_port_generic_info *in_port;
bool is_fe_enabled;
bool is_offline;
};
/*
* struct cam_sfe_hw_sfe_out_acquire_args:
*
* @rsrc_node: Pointer to Resource Node object, filled if acquire
* is successful
* @out_port_info: Output Port details to acquire
* @unique_id: Unique Identity of Context to associate with this
* resource. Used for composite grouping of multiple
* resources in the same context
* @is_dual: Dual SFE or not
* @split_id: In case of Dual SFE, this is Left or Right.
* @is_master: In case of Dual SFE, this is Master or Slave.
* @cdm_ops: CDM operations
*/
struct cam_sfe_hw_sfe_out_acquire_args {
struct cam_isp_resource_node *rsrc_node;
struct cam_isp_out_port_generic_info *out_port_info;
uint32_t unique_id;
uint32_t is_dual;
enum cam_isp_hw_split_id split_id;
uint32_t is_master;
struct cam_cdm_utils_ops *cdm_ops;
};
/*
* struct cam_sfe_acquire_args:
*
* @rsrc_type: Type of Resource (OUT/IN) to acquire
* @tasklet: Tasklet to associate with this resource. This is
* used to schedule bottom of IRQ events associated
* with this resource.
* @priv: Context data
* @event_cb: Callback function to hw mgr in case of hw events
* @sfe_out: Acquire args for SFE_OUT
* @sfe_bus_rd Acquire args for SFE_BUS_READ
* @sfe_in: Acquire args for SFE_IN
*/
struct cam_sfe_acquire_args {
enum cam_isp_resource_type rsrc_type;
void *tasklet;
void *priv;
cam_hw_mgr_event_cb_func event_cb;
union {
struct cam_sfe_hw_sfe_out_acquire_args sfe_out;
struct cam_sfe_hw_sfe_in_acquire_args sfe_in;
struct cam_sfe_hw_sfe_bus_rd_acquire_args sfe_rd;
};
};
/*
* cam_sfe_hw_init()
*
* @Brief: Initialize SFE HW device
*
* @sfe_hw: sfe_hw interface to fill in and return on
* successful initialization
* @hw_idx: Index of SFE HW
*/
int cam_sfe_hw_init(struct cam_hw_intf **sfe_hw, uint32_t hw_idx);
#endif /* _CAM_SFE_HW_INTF_H_ */

263
drivers/cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_core.c Normal file
Näytä tiedosto

@@ -0,0 +1,263 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#include <linux/slab.h>
#include <linux/list.h>
#include "cam_tasklet_util.h"
#include "cam_sfe_hw_intf.h"
#include "cam_sfe_soc.h"
#include "cam_sfe_core.h"
#include "cam_debug_util.h"
static const char drv_name[] = "sfe";
#define SFE_CORE_BASE_IDX 0
int cam_sfe_get_hw_caps(void *hw_priv, void *get_hw_cap_args, uint32_t arg_size)
{
CAM_DBG(CAM_SFE, "Enter");
return 0;
}
int cam_sfe_init_hw(void *hw_priv, void *init_hw_args, uint32_t arg_size)
{
struct cam_hw_info *sfe_hw = hw_priv;
struct cam_hw_soc_info *soc_info = NULL;
struct cam_sfe_hw_core_info *core_info = NULL;
struct cam_isp_resource_node *isp_res = NULL;
int rc = 0;
CAM_DBG(CAM_SFE, "Enter");
if (!hw_priv) {
CAM_ERR(CAM_SFE, "Invalid arguments");
return -EINVAL;
}
mutex_lock(&sfe_hw->hw_mutex);
sfe_hw->open_count++;
if (sfe_hw->open_count > 1) {
mutex_unlock(&sfe_hw->hw_mutex);
CAM_DBG(CAM_SFE, "SFE has already been initialized cnt %d",
sfe_hw->open_count);
return 0;
}
mutex_unlock(&sfe_hw->hw_mutex);
soc_info = &sfe_hw->soc_info;
core_info = (struct cam_sfe_hw_core_info *)sfe_hw->core_info;
/* Turn ON Regulators, Clocks and other SOC resources */
rc = cam_sfe_enable_soc_resources(soc_info);
if (rc) {
CAM_ERR(CAM_SFE, "Enable SOC failed");
rc = -EFAULT;
goto decrement_open_cnt;
}
isp_res = (struct cam_isp_resource_node *)init_hw_args;
if (isp_res && isp_res->init) {
rc = isp_res->init(isp_res, NULL, 0);
if (rc) {
CAM_ERR(CAM_SFE, "init Failed rc=%d", rc);
goto disable_soc;
}
}
CAM_DBG(CAM_SFE, "Enable soc done");
/* Do HW Reset */
rc = cam_sfe_reset(hw_priv, NULL, 0);
if (rc) {
CAM_ERR(CAM_SFE, "Reset Failed rc=%d", rc);
goto deinit_sfe_res;
}
sfe_hw->hw_state = CAM_HW_STATE_POWER_UP;
return rc;
deinit_sfe_res:
if (isp_res && isp_res->deinit)
isp_res->deinit(isp_res, NULL, 0);
disable_soc:
cam_sfe_disable_soc_resources(soc_info);
decrement_open_cnt:
mutex_lock(&sfe_hw->hw_mutex);
sfe_hw->open_count--;
mutex_unlock(&sfe_hw->hw_mutex);
return rc;
}
int cam_sfe_deinit_hw(void *hw_priv, void *deinit_hw_args, uint32_t arg_size)
{
struct cam_hw_info *sfe_hw = hw_priv;
struct cam_hw_soc_info *soc_info = NULL;
struct cam_sfe_hw_core_info *core_info = NULL;
struct cam_isp_resource_node *isp_res = NULL;
int rc = 0;
CAM_DBG(CAM_SFE, "Enter");
if (!hw_priv) {
CAM_ERR(CAM_SFE, "Invalid arguments");
return -EINVAL;
}
mutex_lock(&sfe_hw->hw_mutex);
if (!sfe_hw->open_count) {
mutex_unlock(&sfe_hw->hw_mutex);
CAM_ERR(CAM_SFE, "Error! Unbalanced deinit");
return -EFAULT;
}
sfe_hw->open_count--;
if (sfe_hw->open_count) {
mutex_unlock(&sfe_hw->hw_mutex);
CAM_DBG(CAM_SFE, "open_cnt non-zero =%d", sfe_hw->open_count);
return 0;
}
mutex_unlock(&sfe_hw->hw_mutex);
soc_info = &sfe_hw->soc_info;
core_info = (struct cam_sfe_hw_core_info *)sfe_hw->core_info;
isp_res = (struct cam_isp_resource_node *)deinit_hw_args;
if (isp_res && isp_res->deinit) {
rc = isp_res->deinit(isp_res, NULL, 0);
if (rc)
CAM_ERR(CAM_SFE, "deinit failed");
}
/* Turn OFF Regulators, Clocks and other SOC resources */
CAM_DBG(CAM_SFE, "Disable SOC resource");
rc = cam_sfe_disable_soc_resources(soc_info);
if (rc)
CAM_ERR(CAM_SFE, "Disable SOC failed");
sfe_hw->hw_state = CAM_HW_STATE_POWER_DOWN;
CAM_DBG(CAM_SFE, "Exit");
return rc;
}
int cam_sfe_reset(void *hw_priv, void *reset_core_args, uint32_t arg_size)
{
CAM_DBG(CAM_SFE, "Enter");
return 0;
}
int cam_sfe_reserve(void *hw_priv, void *reserve_args, uint32_t arg_size)
{
CAM_DBG(CAM_SFE, "Enter");
return 0;
}
int cam_sfe_release(void *hw_priv, void *release_args, uint32_t arg_size)
{
CAM_DBG(CAM_SFE, "Enter");
return 0;
}
int cam_sfe_start(void *hw_priv, void *start_args, uint32_t arg_size)
{
CAM_DBG(CAM_SFE, "Enter");
return 0;
}
int cam_sfe_stop(void *hw_priv, void *stop_args, uint32_t arg_size)
{
CAM_DBG(CAM_SFE, "Enter");
return 0;
}
int cam_sfe_read(void *hw_priv, void *read_args, uint32_t arg_size)
{
return -EPERM;
}
int cam_sfe_write(void *hw_priv, void *write_args, uint32_t arg_size)
{
return -EPERM;
}
int cam_sfe_process_cmd(void *hw_priv, uint32_t cmd_type,
void *cmd_args, uint32_t arg_size)
{
struct cam_hw_info *sfe_hw = hw_priv;
struct cam_hw_soc_info *soc_info = NULL;
struct cam_sfe_hw_core_info *core_info = NULL;
struct cam_sfe_hw_info *hw_info = NULL;
int rc;
if (!hw_priv) {
CAM_ERR(CAM_SFE, "Invalid arguments");
return -EINVAL;
}
soc_info = &sfe_hw->soc_info;
core_info = (struct cam_sfe_hw_core_info *)sfe_hw->core_info;
hw_info = core_info->sfe_hw_info;
switch (cmd_type) {
case CAM_ISP_HW_CMD_GET_CHANGE_BASE:
case CAM_ISP_HW_CMD_GET_REG_UPDATE:
rc = 0;
break;
default:
CAM_ERR(CAM_SFE, "Invalid cmd type:%d", cmd_type);
rc = -EINVAL;
break;
}
return rc;
}
irqreturn_t cam_sfe_irq(int irq_num, void *data)
{
struct cam_hw_info *sfe_hw;
struct cam_sfe_hw_core_info *core_info;
if (!data)
return IRQ_NONE;
sfe_hw = (struct cam_hw_info *)data;
core_info = (struct cam_sfe_hw_core_info *)sfe_hw->core_info;
return cam_irq_controller_handle_irq(irq_num,
core_info->sfe_irq_controller);
}
int cam_sfe_core_init(
struct cam_sfe_hw_core_info *core_info,
struct cam_hw_soc_info *soc_info,
struct cam_hw_intf *hw_intf,
struct cam_sfe_hw_info *sfe_hw_info)
{
CAM_DBG(CAM_SFE, "Enter");
INIT_LIST_HEAD(&core_info->free_payload_list);
spin_lock_init(&core_info->spin_lock);
return 0;
}
int cam_sfe_core_deinit(
struct cam_sfe_hw_core_info *core_info,
struct cam_sfe_hw_info *sfe_hw_info)
{
int rc = -EINVAL;
unsigned long flags;
spin_lock_irqsave(&core_info->spin_lock, flags);
INIT_LIST_HEAD(&core_info->free_payload_list);
rc = cam_irq_controller_deinit(&core_info->sfe_irq_controller);
if (rc)
CAM_ERR(CAM_SFE,
"Error cam_irq_controller_deinit failed rc=%d", rc);
spin_unlock_irqrestore(&core_info->spin_lock, flags);
return rc;
}

61
drivers/cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_core.h Normal file
Näytä tiedosto

@@ -0,0 +1,61 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_SFE_CORE_H_
#define _CAM_SFE_CORE_H_
#include <linux/spinlock.h>
#include "cam_hw_intf.h"
#include "cam_sfe_hw_intf.h"
struct cam_sfe_hw_info {
struct cam_irq_controller_reg_info *irq_reg_info;
};
#define CAM_SFE_EVT_MAX 256
struct cam_sfe_hw_core_info {
struct cam_sfe_hw_info *sfe_hw_info;
void *sfe_irq_controller;
void *tasklet_info;
struct list_head free_payload_list;
spinlock_t spin_lock;
int irq_handle;
};
int cam_sfe_get_hw_caps(void *device_priv,
void *get_hw_cap_args, uint32_t arg_size);
int cam_sfe_init_hw(void *device_priv,
void *init_hw_args, uint32_t arg_size);
int cam_sfe_deinit_hw(void *hw_priv,
void *deinit_hw_args, uint32_t arg_size);
int cam_sfe_reset(void *device_priv,
void *reset_core_args, uint32_t arg_size);
int cam_sfe_reserve(void *device_priv,
void *reserve_args, uint32_t arg_size);
int cam_sfe_release(void *device_priv,
void *reserve_args, uint32_t arg_size);
int cam_sfe_start(void *device_priv,
void *start_args, uint32_t arg_size);
int cam_sfe_stop(void *device_priv,
void *stop_args, uint32_t arg_size);
int cam_sfe_read(void *device_priv,
void *read_args, uint32_t arg_size);
int cam_sfe_write(void *device_priv,
void *write_args, uint32_t arg_size);
int cam_sfe_process_cmd(void *device_priv, uint32_t cmd_type,
void *cmd_args, uint32_t arg_size);
irqreturn_t cam_sfe_irq(int irq_num, void *data);
int cam_sfe_core_init(struct cam_sfe_hw_core_info *core_info,
struct cam_hw_soc_info *soc_info,
struct cam_hw_intf *hw_intf,
struct cam_sfe_hw_info *sfe_hw_info);
int cam_sfe_core_deinit(struct cam_sfe_hw_core_info *core_info,
struct cam_sfe_hw_info *sfe_hw_info);
#endif /* _CAM_SFE_CORE_H_ */

193
drivers/cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_dev.c Normal file
Näytä tiedosto

@@ -0,0 +1,193 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#include <linux/slab.h>
#include <linux/mod_devicetable.h>
#include <linux/of_device.h>
#include "cam_sfe_dev.h"
#include "cam_sfe_core.h"
#include "cam_sfe_soc.h"
#include "cam_sfe_hw_intf.h"
#include "cam_debug_util.h"
static struct cam_hw_intf *sfe_instance;
static char sfe_dev_name[8];
int cam_sfe_probe(struct platform_device *pdev)
{
struct cam_hw_info *sfe_info = NULL;
struct cam_hw_intf *sfe_intf = NULL;
const struct of_device_id *match_dev = NULL;
struct cam_sfe_hw_core_info *core_info = NULL;
struct cam_sfe_hw_info *hw_info = NULL;
int rc = 0;
sfe_intf = kzalloc(sizeof(struct cam_hw_intf), GFP_KERNEL);
if (!sfe_intf) {
rc = -ENOMEM;
goto end;
}
of_property_read_u32(pdev->dev.of_node,
"cell-index", &sfe_intf->hw_idx);
sfe_info = kzalloc(sizeof(struct cam_hw_info), GFP_KERNEL);
if (!sfe_info) {
rc = -ENOMEM;
goto free_sfe_intf;
}
memset(sfe_dev_name, 0, sizeof(sfe_dev_name));
snprintf(sfe_dev_name, sizeof(sfe_dev_name),
"sfe%1u", sfe_intf->hw_idx);
sfe_info->soc_info.pdev = pdev;
sfe_info->soc_info.dev = &pdev->dev;
sfe_info->soc_info.dev_name = sfe_dev_name;
sfe_intf->hw_priv = sfe_info;
sfe_intf->hw_ops.get_hw_caps = cam_sfe_get_hw_caps;
sfe_intf->hw_ops.init = cam_sfe_init_hw;
sfe_intf->hw_ops.deinit = cam_sfe_deinit_hw;
sfe_intf->hw_ops.reset = cam_sfe_reset;
sfe_intf->hw_ops.reserve = cam_sfe_reserve;
sfe_intf->hw_ops.release = cam_sfe_release;
sfe_intf->hw_ops.start = cam_sfe_start;
sfe_intf->hw_ops.stop = cam_sfe_stop;
sfe_intf->hw_ops.read = cam_sfe_read;
sfe_intf->hw_ops.write = cam_sfe_write;
sfe_intf->hw_ops.process_cmd = cam_sfe_process_cmd;
sfe_intf->hw_type = CAM_ISP_HW_TYPE_SFE;
CAM_DBG(CAM_SFE, "type %d index %d",
sfe_intf->hw_type, sfe_intf->hw_idx);
platform_set_drvdata(pdev, sfe_intf);
sfe_info->core_info = kzalloc(sizeof(struct cam_sfe_hw_core_info),
GFP_KERNEL);
if (!sfe_info->core_info) {
CAM_DBG(CAM_SFE, "Failed to alloc for core");
rc = -ENOMEM;
goto free_sfe_hw;
}
core_info = (struct cam_sfe_hw_core_info *)sfe_info->core_info;
match_dev = of_match_device(pdev->dev.driver->of_match_table,
&pdev->dev);
if (!match_dev) {
CAM_ERR(CAM_SFE, "Of_match Failed");
rc = -EINVAL;
goto free_core_info;
}
hw_info = (struct cam_sfe_hw_info *)match_dev->data;
core_info->sfe_hw_info = hw_info;
rc = cam_sfe_init_soc_resources(&sfe_info->soc_info, cam_sfe_irq,
sfe_info);
if (rc < 0) {
CAM_ERR(CAM_SFE, "Failed to init soc rc=%d", rc);
goto free_core_info;
}
rc = cam_sfe_core_init(core_info, &sfe_info->soc_info,
sfe_intf, hw_info);
if (rc < 0) {
CAM_ERR(CAM_SFE, "Failed to init core rc=%d", rc);
goto deinit_soc;
}
sfe_info->hw_state = CAM_HW_STATE_POWER_DOWN;
mutex_init(&sfe_info->hw_mutex);
spin_lock_init(&sfe_info->hw_lock);
init_completion(&sfe_info->hw_complete);
sfe_instance = sfe_intf;
CAM_DBG(CAM_SFE, "SFE%d probe successful", sfe_intf->hw_idx);
return rc;
deinit_soc:
if (cam_sfe_deinit_soc_resources(&sfe_info->soc_info))
CAM_ERR(CAM_SFE, "Failed to deinit soc");
free_core_info:
kfree(sfe_info->core_info);
free_sfe_hw:
kfree(sfe_info);
free_sfe_intf:
kfree(sfe_intf);
end:
return rc;
}
int cam_sfe_remove(struct platform_device *pdev)
{
struct cam_hw_info *sfe_info = NULL;
struct cam_hw_intf *sfe_intf = NULL;
struct cam_sfe_hw_core_info *core_info = NULL;
int rc = 0;
sfe_intf = platform_get_drvdata(pdev);
if (!sfe_intf) {
CAM_ERR(CAM_SFE, "Error! No data in pdev");
return -EINVAL;
}
CAM_DBG(CAM_SFE, "type %d index %d",
sfe_intf->hw_type, sfe_intf->hw_idx);
sfe_instance = NULL;
sfe_info = sfe_intf->hw_priv;
if (!sfe_info) {
CAM_ERR(CAM_SFE, "Error! HW data is NULL");
rc = -ENODEV;
goto free_sfe_intf;
}
core_info = (struct cam_sfe_hw_core_info *)sfe_info->core_info;
if (!core_info) {
CAM_ERR(CAM_SFE, "Error! core data NULL");
rc = -EINVAL;
goto deinit_soc;
}
rc = cam_sfe_core_deinit(core_info, core_info->sfe_hw_info);
if (rc < 0)
CAM_ERR(CAM_SFE, "Failed to deinit core rc=%d", rc);
kfree(sfe_info->core_info);
deinit_soc:
rc = cam_sfe_deinit_soc_resources(&sfe_info->soc_info);
if (rc < 0)
CAM_ERR(CAM_SFE, "Failed to deinit soc rc=%d", rc);
mutex_destroy(&sfe_info->hw_mutex);
kfree(sfe_info);
CAM_DBG(CAM_SFE, "SFE%d remove successful", sfe_intf->hw_idx);
free_sfe_intf:
kfree(sfe_intf);
return rc;
}
int cam_sfe_hw_init(struct cam_hw_intf **sfe_intf, uint32_t hw_idx)
{
int rc = 0;
if (sfe_instance) {
*sfe_intf = sfe_instance;
rc = 0;
} else {
*sfe_intf = NULL;
rc = -ENODEV;
}
return rc;
}

35
drivers/cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_dev.h Normal file
Näytä tiedosto

@@ -0,0 +1,35 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_SFE_DEV_H_
#define _CAM_SFE_DEV_H_
#include <linux/platform_device.h>
/*
* cam_sfe_probe()
*
* @brief: Driver probe function called on Boot
*
* @pdev: Platform Device pointer
*
* @Return: 0: Success
* Non-zero: Failure
*/
int cam_sfe_probe(struct platform_device *pdev);
/*
* cam_sfe_remove()
*
* @brief: Driver remove function
*
* @pdev: Platform Device pointer
*
* @Return: 0: Success
* Non-zero: Failure
*/
int cam_sfe_remove(struct platform_device *pdev);
#endif /* _CAM_SFE_DEV_H_ */

126
drivers/cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_soc.c Normal file
Näytä tiedosto

@@ -0,0 +1,126 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#include <linux/slab.h>
#include "cam_cpas_api.h"
#include "cam_sfe_soc.h"
#include "cam_debug_util.h"
static int cam_sfe_get_dt_properties(struct cam_hw_soc_info *soc_info)
{
int rc = 0;
rc = cam_soc_util_get_dt_properties(soc_info);
if (rc)
CAM_ERR(CAM_SFE, "Error get DT properties failed rc=%d", rc);
return rc;
}
static int cam_sfe_request_platform_resource(
struct cam_hw_soc_info *soc_info,
irq_handler_t irq_handler_func, void *irq_data)
{
int rc = 0;
rc = cam_soc_util_request_platform_resource(soc_info, irq_handler_func,
irq_data);
if (rc)
CAM_ERR(CAM_SFE,
"Error Request platform resource failed rc=%d", rc);
return rc;
}
static int cam_sfe_release_platform_resource(struct cam_hw_soc_info *soc_info)
{
int rc = 0;
rc = cam_soc_util_release_platform_resource(soc_info);
if (rc)
CAM_ERR(CAM_SFE,
"Error Release platform resource failed rc=%d", rc);
return rc;
}
int cam_sfe_init_soc_resources(struct cam_hw_soc_info *soc_info,
irq_handler_t irq_handler_func, void *irq_data)
{
int rc = 0;
rc = cam_sfe_get_dt_properties(soc_info);
if (rc < 0) {
CAM_ERR(CAM_SFE, "Error Get DT properties failed rc=%d", rc);
goto end;
}
rc = cam_sfe_request_platform_resource(soc_info,
irq_handler_func, irq_data);
if (rc < 0) {
CAM_ERR(CAM_SFE,
"Error Request platform resources failed rc=%d", rc);
goto end;
}
end:
return rc;
}
int cam_sfe_deinit_soc_resources(struct cam_hw_soc_info *soc_info)
{
int rc = 0;
if (!soc_info) {
CAM_ERR(CAM_SFE, "Error soc_info NULL");
return -ENODEV;
}
rc = cam_sfe_release_platform_resource(soc_info);
if (rc < 0)
CAM_ERR(CAM_SFE,
"Error Release platform resources failed rc=%d", rc);
return rc;
}
int cam_sfe_enable_soc_resources(struct cam_hw_soc_info *soc_info)
{
int rc = 0;
rc = cam_soc_util_enable_platform_resource(soc_info, true,
CAM_TURBO_VOTE, true);
if (rc) {
CAM_ERR(CAM_SFE, "Error enable platform failed rc=%d", rc);
goto end;
}
end:
return rc;
}
int cam_sfe_soc_enable_clk(struct cam_hw_soc_info *soc_info,
const char *clk_name)
{
return -EPERM;
}
int cam_sfe_soc_disable_clk(struct cam_hw_soc_info *soc_info,
const char *clk_name)
{
return -EPERM;
}
int cam_sfe_disable_soc_resources(struct cam_hw_soc_info *soc_info)
{
int rc = 0;
rc = cam_soc_util_disable_platform_resource(soc_info, true, true);
if (rc)
CAM_ERR(CAM_SFE, "Disable platform failed rc=%d", rc);
return rc;
}

106
drivers/cam_isp/isp_hw_mgr/isp_hw/sfe_hw/cam_sfe_soc.h Normal file
Näytä tiedosto

@@ -0,0 +1,106 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_SFE_SOC_H_
#define _CAM_SFE_SOC_H_
#include "cam_soc_util.h"
#include "cam_isp_hw.h"
/*
* struct cam_sfe_soc_private:
*
* @Brief: Private SOC data specific to SFE HW Driver
*
* @cpas_handle: Handle returned on registering with CPAS driver
* This handle is used for all further interface
* with CPAS.
* @cpas_version: CPAS version
*/
struct cam_sfe_soc_private {
uint32_t cpas_handle;
uint32_t cpas_version;
};
/*
* cam_sfe_init_soc_resources()
*
* @Brief: Initialize SOC resources including private data
*
* @soc_info: Device soc information
* @handler: Irq handler function pointer
* @irq_data: Irq handler function Callback data
*
* @Return: 0: Success
* Non-zero: Failure
*/
int cam_sfe_init_soc_resources(struct cam_hw_soc_info *soc_info,
irq_handler_t vfe_irq_handler, void *irq_data);
/*
* cam_sfe_deinit_soc_resources()
*
* @Brief: Deinitialize SOC resources including private data
*
* @soc_info: Device soc information
*
* @Return: 0: Success
* Non-zero: Failure
*/
int cam_sfe_deinit_soc_resources(struct cam_hw_soc_info *soc_info);
/*
* cam_sfe_enable_soc_resources()
*
* @brief: Enable regulator, irq resources, Clocks
*
* @soc_info: Device soc information
*
* @Return: 0: Success
* Non-zero: Failure
*/
int cam_sfe_enable_soc_resources(struct cam_hw_soc_info *soc_info);
/*
* cam_sfe_disable_soc_resources()
*
* @brief: Disable regulator, irq resources, Clocks
*
* @soc_info: Device soc information
*
* @Return: 0: Success
* Non-zero: Failure
*/
int cam_sfe_disable_soc_resources(struct cam_hw_soc_info *soc_info);
/*
* cam_sfe_soc_enable_clk()
*
* @brief: Enable clock wsfe given name
*
* @soc_info: Device soc information
* @clk_name: Name of clock to enable
*
* @Return: 0: Success
* Non-zero: Failure
*/
extern int cam_sfe_soc_enable_clk(struct cam_hw_soc_info *soc_info,
const char *clk_name);
/*
* cam_sfe_soc_disable_clk()
*
* @brief: Disable clock wsfe given name
*
* @soc_info: Device soc information
* @clk_name: Name of clock to enable
*
* @Return: 0: Success
* Non-zero: Failure
*/
int cam_sfe_soc_disable_clk(struct cam_hw_soc_info *soc_info,
const char *clk_name);
#endif /* _CAM_SFE_SOC_H_ */

3
drivers/cam_utils/cam_debug_util.c
Näytä tiedosto

@@ -215,6 +215,9 @@ const char *cam_get_module_name(unsigned int module_id)
case CAM_IO_ACCESS:
name = "CAM-IO-ACCESS";
break;
case CAM_SFE:
name = "CAM-SFE";
break;
default:
name = "CAM";
break;

1
drivers/cam_utils/cam_debug_util.h
Näytä tiedosto

@@ -39,6 +39,7 @@
#define CAM_PRESIL (1 << 27)
#define CAM_OPE (1 << 28)
#define CAM_IO_ACCESS (1 << 29)
#define CAM_SFE (1 << 30)
/* Log level types */
#define CAM_TYPE_TRACE (1 << 0)