A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-08 21:22:09 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge "msm: camera: jpeg: Handle JPEG smmu fault with pid info" into camera-kernel.lnx.4.0

Browse source
This commit is contained in:
Camera Software Integration 2021-03-03 05:38:24 -08:00 • committed by Gerrit - the friendly Code Review server
commit 85d260ec72
13 changed files with 366 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

194
drivers/cam_jpeg/jpeg_hw/cam_jpeg_hw_mgr.c
View file

@ -694,75 +694,6 @@ err_after_dq_free_list:
return rc;
}
static void cam_jpeg_mgr_print_io_bufs(struct cam_packet *packet,
int32_t iommu_hdl, int32_t sec_mmu_hdl, uint32_t pf_buf_info,
bool *mem_found)
{
dma_addr_t iova_addr;
size_t src_buf_size;
int i;
int j;
int rc = 0;
int32_t mmu_hdl;
struct cam_buf_io_cfg *io_cfg = NULL;
if (mem_found)
*mem_found = false;
io_cfg = (struct cam_buf_io_cfg *)((uint32_t *)&packet->payload +
packet->io_configs_offset / 4);
for (i = 0; i < packet->num_io_configs; i++) {
for (j = 0; j < CAM_PACKET_MAX_PLANES; j++) {
if (!io_cfg[i].mem_handle[j])
break;
if (GET_FD_FROM_HANDLE(io_cfg[i].mem_handle[j]) ==
GET_FD_FROM_HANDLE(pf_buf_info)) {
CAM_INFO(CAM_JPEG,
"Found PF at port: %d mem %x fd: %x",
io_cfg[i].resource_type,
io_cfg[i].mem_handle[j],
pf_buf_info);
if (mem_found)
*mem_found = true;
}
CAM_INFO(CAM_JPEG, "port: %d f: %u format: %d dir %d",
io_cfg[i].resource_type,
io_cfg[i].fence,
io_cfg[i].format,
io_cfg[i].direction);
mmu_hdl = cam_mem_is_secure_buf(
io_cfg[i].mem_handle[j]) ? sec_mmu_hdl :
iommu_hdl;
rc = cam_mem_get_io_buf(io_cfg[i].mem_handle[j],
mmu_hdl, &iova_addr, &src_buf_size);
if (rc < 0) {
CAM_ERR(CAM_UTIL, "get src buf address fail");
continue;
}
if ((iova_addr & 0xFFFFFFFF) != iova_addr) {
CAM_ERR(CAM_JPEG, "Invalid mapped address");
rc = -EINVAL;
continue;
}
CAM_INFO(CAM_JPEG,
"pln %u w %u h %u stride %u slice %u size %d addr 0x%x offset 0x%x memh %x",
j, io_cfg[i].planes[j].width,
io_cfg[i].planes[j].height,
io_cfg[i].planes[j].plane_stride,
io_cfg[i].planes[j].slice_height,
(int32_t)src_buf_size,
(unsigned int)iova_addr,
io_cfg[i].offsets[j],
io_cfg[i].mem_handle[j]);
}
}
}
static int cam_jpeg_mgr_prepare_hw_update(void *hw_mgr_priv,
void *prepare_hw_update_args)
{
@ -1570,6 +1501,18 @@ static int cam_jpeg_init_devices(struct device_node *of_node,
g_jpeg_hw_mgr.cdm_reg_map[CAM_JPEG_DEV_DMA][0] =
&dma_soc_info->reg_map[0];
rc = g_jpeg_hw_mgr.devices[CAM_JPEG_DEV_ENC][0]->hw_ops.process_cmd(
g_jpeg_hw_mgr.devices[CAM_JPEG_DEV_ENC][0]->hw_priv,
CAM_JPEG_CMD_GET_NUM_PID,
&g_jpeg_hw_mgr.num_pid[CAM_JPEG_DEV_ENC],
sizeof(uint32_t));
rc = g_jpeg_hw_mgr.devices[CAM_JPEG_DEV_DMA][0]->hw_ops.process_cmd(
g_jpeg_hw_mgr.devices[CAM_JPEG_DEV_DMA][0]->hw_priv,
CAM_JPEG_CMD_GET_NUM_PID,
&g_jpeg_hw_mgr.num_pid[CAM_JPEG_DEV_DMA],
sizeof(uint32_t));
*p_num_enc_dev = num_dev;
*p_num_dma_dev = num_dma_dev;
@ -1722,6 +1665,109 @@ hw_dump:
return rc;
}
static void cam_jpeg_mgr_dump_pf_data(
struct cam_jpeg_hw_mgr *hw_mgr,
struct cam_hw_cmd_args *hw_cmd_args)
{
struct cam_jpeg_hw_ctx_data *ctx_data;
struct cam_packet *packet;
struct cam_jpeg_match_pid_args jpeg_pid_mid_args;
struct cam_buf_io_cfg *io_cfg = NULL;
uint32_t dev_type;
dma_addr_t iova_addr;
size_t src_buf_size;
int i, j;
int32_t mmu_hdl;
bool hw_pid_support = true;
int rc = 0;
ctx_data = (struct cam_jpeg_hw_ctx_data *)hw_cmd_args->ctxt_to_hw_map;
packet = hw_cmd_args->u.pf_args.pf_data.packet;
jpeg_pid_mid_args.fault_mid = hw_cmd_args->u.pf_args.mid;
jpeg_pid_mid_args.pid = hw_cmd_args->u.pf_args.pid;
dev_type = ctx_data->jpeg_dev_acquire_info.dev_type;
if (!hw_mgr->num_pid[dev_type]) {
hw_pid_support = false;
goto iodump;
}
rc = hw_mgr->devices[dev_type][0]->hw_ops.process_cmd(
hw_mgr->devices[dev_type][0]->hw_priv,
CAM_JPEG_CMD_MATCH_PID_MID,
&jpeg_pid_mid_args, sizeof(jpeg_pid_mid_args));
if (rc) {
CAM_ERR(CAM_JPEG, "CAM_JPEG_CMD_MATCH_PID_MID failed %d", rc);
return;
}
if (!jpeg_pid_mid_args.pid_match_found) {
CAM_INFO(CAM_JPEG, "This context data is not matched with pf pid and mid");
return;
}
iodump:
io_cfg = (struct cam_buf_io_cfg *)((uint32_t *)&packet->payload +
packet->io_configs_offset / 4);
for (i = 0; i < packet->num_io_configs; i++) {
if (hw_pid_support) {
if (io_cfg[i].resource_type !=
jpeg_pid_mid_args.match_res)
continue;
if (i == packet->num_io_configs) {
CAM_ERR(CAM_JPEG,
"getting io port for mid resource id failed req id:%lld res id:0x%x",
packet->header.request_id,
jpeg_pid_mid_args.match_res);
return;
}
}
for (j = 0; j < CAM_PACKET_MAX_PLANES; j++) {
if (!io_cfg[i].mem_handle[j])
break;
CAM_INFO(CAM_JPEG, "port: %d f: %u format: %d dir %d",
io_cfg[i].resource_type,
io_cfg[i].fence,
io_cfg[i].format,
io_cfg[i].direction);
mmu_hdl = cam_mem_is_secure_buf(
io_cfg[i].mem_handle[j]) ? hw_mgr->iommu_sec_hdl :
hw_mgr->iommu_hdl;
rc = cam_mem_get_io_buf(io_cfg[i].mem_handle[j],
mmu_hdl, &iova_addr, &src_buf_size);
if (rc < 0) {
CAM_ERR(CAM_UTIL, "get src buf address fail");
continue;
}
if ((iova_addr & 0xFFFFFFFF) != iova_addr) {
CAM_ERR(CAM_JPEG, "Invalid mapped address");
rc = -EINVAL;
continue;
}
CAM_INFO(CAM_JPEG,
"pln %u w %u h %u stride %u slice %u size %d addr 0x%x offset 0x%x memh %x",
j, io_cfg[i].planes[j].width,
io_cfg[i].planes[j].height,
io_cfg[i].planes[j].plane_stride,
io_cfg[i].planes[j].slice_height,
(int32_t)src_buf_size,
(unsigned int)iova_addr,
io_cfg[i].offsets[j],
io_cfg[i].mem_handle[j]);
}
if (hw_pid_support)
return;
}
}
static int cam_jpeg_mgr_cmd(void *hw_mgr_priv, void *cmd_args)
{
int rc = 0;
@ -1735,15 +1781,11 @@ static int cam_jpeg_mgr_cmd(void *hw_mgr_priv, void *cmd_args)
switch (hw_cmd_args->cmd_type) {
case CAM_HW_MGR_CMD_DUMP_PF_INFO:
cam_jpeg_mgr_print_io_bufs(
hw_cmd_args->u.pf_args.pf_data.packet,
hw_mgr->iommu_hdl,
hw_mgr->iommu_sec_hdl,
hw_cmd_args->u.pf_args.buf_info,
hw_cmd_args->u.pf_args.mem_found);
cam_jpeg_mgr_dump_pf_data(hw_mgr, hw_cmd_args);
break;
default:
CAM_ERR(CAM_JPEG, "Invalid cmd");
CAM_ERR(CAM_JPEG, "Invalid cmd :%d",
hw_cmd_args->cmd_type);
}
return rc;

2
drivers/cam_jpeg/jpeg_hw/cam_jpeg_hw_mgr.h
View file

@ -132,6 +132,7 @@ struct cam_jpeg_hw_ctx_data {
* @hw_config_req_list: Pending hw update requests list
* @free_req_list: Free nodes for above list
* @req_list: Nodes of hw update list
* @num_pid: num of pids supported in the device
*/
struct cam_jpeg_hw_mgr {
struct mutex hw_mgr_mutex;
@ -160,6 +161,7 @@ struct cam_jpeg_hw_mgr {
struct list_head hw_config_req_list;
struct list_head free_req_list;
struct cam_jpeg_hw_cfg_req req_list[CAM_JPEG_HW_CFG_Q_MAX];
uint32_t num_pid[CAM_JPEG_DEV_TYPE_MAX];
};
#endif /* CAM_JPEG_HW_MGR_H */

12
drivers/cam_jpeg/jpeg_hw/include/cam_jpeg_hw_intf.h
View file

@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
*/
#ifndef CAM_JPEG_HW_INTF_H
@ -17,6 +17,7 @@
#define CAM_JPEG_HW_DUMP_TAG_MAX_LEN 32
#define CAM_JPEG_HW_DUMP_NUM_WORDS 5
#define CAM_JPEG_HW_MAX_NUM_PID 2
enum cam_jpeg_hw_type {
CAM_JPEG_DEV_ENC,
@ -43,10 +44,19 @@ struct cam_jpeg_hw_dump_header {
uint32_t word_size;
};
struct cam_jpeg_match_pid_args {
uint32_t pid;
uint32_t fault_mid;
bool pid_match_found;
uint32_t match_res;
};
enum cam_jpeg_cmd_type {
CAM_JPEG_CMD_CDM_CFG,
CAM_JPEG_CMD_SET_IRQ_CB,
CAM_JPEG_CMD_HW_DUMP,
CAM_JPEG_CMD_GET_NUM_PID,
CAM_JPEG_CMD_MATCH_PID_MID,
CAM_JPEG_CMD_MAX,
};

47
drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_core.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
*/
#include <linux/of.h>
@ -377,7 +377,9 @@ int cam_jpeg_dma_process_cmd(void *device_priv, uint32_t cmd_type,
{
struct cam_hw_info *jpeg_dma_dev = device_priv;
struct cam_jpeg_dma_device_core_info *core_info = NULL;
int rc;
struct cam_jpeg_match_pid_args *match_pid_mid = NULL;
uint32_t *num_pid = NULL;
int i, rc = 0;
if (!device_priv) {
CAM_ERR(CAM_JPEG, "Invalid arguments");
@ -412,6 +414,47 @@ int cam_jpeg_dma_process_cmd(void *device_priv, uint32_t cmd_type,
rc = 0;
break;
}
case CAM_JPEG_CMD_GET_NUM_PID:
if (!cmd_args) {
CAM_ERR(CAM_JPEG, "cmd args NULL");
return -EINVAL;
}
num_pid = (uint32_t *)cmd_args;
*num_pid = core_info->num_pid;
break;
case CAM_JPEG_CMD_MATCH_PID_MID:
match_pid_mid = (struct cam_jpeg_match_pid_args *)cmd_args;
if (!cmd_args) {
CAM_ERR(CAM_JPEG, "cmd args NULL");
return -EINVAL;
}
for (i = 0; i < core_info->num_pid; i++) {
if (core_info->pid[i] == match_pid_mid->pid)
break;
}
if (i == core_info->num_pid)
match_pid_mid->pid_match_found = false;
else
match_pid_mid->pid_match_found = true;
if (match_pid_mid->pid_match_found) {
if (match_pid_mid->fault_mid == core_info->rd_mid) {
match_pid_mid->match_res =
CAM_JPEG_DMA_INPUT_IMAGE;
} else if (match_pid_mid->fault_mid ==
core_info->wr_mid) {
match_pid_mid->match_res =
CAM_JPEG_DMA_OUTPUT_IMAGE;
} else
match_pid_mid->pid_match_found = false;
}
break;
default:
rc = -EINVAL;
break;

6
drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_core.h
View file

@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
*/
#ifndef CAM_JPEG_DMA_CORE_H
@ -63,6 +63,10 @@ struct cam_jpeg_dma_device_core_info {
int32_t ref_count;
struct mutex core_mutex;
int32_t result_size;
uint32_t num_pid;
uint32_t pid[CAM_JPEG_HW_MAX_NUM_PID];
uint32_t rd_mid;
uint32_t wr_mid;
};
int cam_jpeg_dma_init_hw(void *device_priv,

16
drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_dev.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@ -66,7 +66,8 @@ static int cam_jpeg_dma_component_bind(struct device *dev,
const struct of_device_id *match_dev = NULL;
struct cam_jpeg_dma_device_core_info *core_info = NULL;
struct cam_jpeg_dma_device_hw_info *hw_info = NULL;
int rc;
struct cam_jpeg_dma_soc_private *soc_private;
int i, rc;
struct platform_device *pdev = to_platform_device(dev);
jpeg_dma_dev_intf = kzalloc(sizeof(struct cam_hw_intf), GFP_KERNEL);
@ -135,6 +136,17 @@ static int cam_jpeg_dma_component_bind(struct device *dev,
spin_lock_init(&jpeg_dma_dev->hw_lock);
init_completion(&jpeg_dma_dev->hw_complete);
CAM_DBG(CAM_JPEG, "JPEG-DMA component bound successfully");
soc_private = (struct cam_jpeg_dma_soc_private *)
jpeg_dma_dev->soc_info.soc_private;
core_info->num_pid = soc_private->num_pid;
for (i = 0; i < soc_private->num_pid; i++)
core_info->pid[i] = soc_private->pid[i];
core_info->rd_mid = soc_private->rd_mid;
core_info->wr_mid = soc_private->wr_mid;
return rc;
error_reg_cpas:

36
drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_soc.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2019, 2021 The Linux Foundation. All rights reserved.
*/
#include <linux/io.h>
@ -16,8 +16,20 @@
int cam_jpeg_dma_init_soc_resources(struct cam_hw_soc_info *soc_info,
irq_handler_t jpeg_dma_irq_handler, void *irq_data)
{
struct cam_jpeg_dma_soc_private *soc_private;
struct platform_device *pdev = NULL;
int num_pid = 0, i = 0;
int rc;
soc_private = kzalloc(sizeof(struct cam_jpeg_dma_soc_private),
GFP_KERNEL);
if (!soc_private) {
CAM_DBG(CAM_JPEG, "Error! soc_private Alloc Failed");
return -ENOMEM;
}
soc_info->soc_private = soc_private;
pdev = soc_info->pdev;
rc = cam_soc_util_get_dt_properties(soc_info);
if (rc)
return rc;
@ -28,6 +40,28 @@ int cam_jpeg_dma_init_soc_resources(struct cam_hw_soc_info *soc_info,
if (rc)
CAM_ERR(CAM_JPEG, "init soc failed %d", rc);
soc_private->num_pid = 0;
soc_private->rd_mid = UINT_MAX;
soc_private->wr_mid = UINT_MAX;
num_pid = of_property_count_u32_elems(pdev->dev.of_node, "cam_hw_pid");
CAM_DBG(CAM_JPEG, "jpeg:%d pid count %d", soc_info->index, num_pid);
if (num_pid <= 0 || num_pid > CAM_JPEG_HW_MAX_NUM_PID)
goto end;
soc_private->num_pid = num_pid;
for (i = 0; i < num_pid; i++)
of_property_read_u32_index(pdev->dev.of_node, "cam_hw_pid", i,
&soc_private->pid[i]);
of_property_read_u32(pdev->dev.of_node,
"cam_hw_rd_mid", &soc_private->rd_mid);
of_property_read_u32(pdev->dev.of_node,
"cam_hw_wr_mid", &soc_private->wr_mid);
end:
return rc;
}

20
drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_soc.h
View file

@ -1,12 +1,30 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2018, 2021 The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_JPEG_DMA_SOC_H_
#define _CAM_JPEG_DMA_SOC_H_
#include "cam_soc_util.h"
#include "cam_jpeg_hw_intf.h"
/*
* struct cam_jpeg_dma_soc_private:
*
* @Brief: Private SOC data specific to JPEG DMA Driver
*
* @num_pid JPEG number of pids
* @pid: JPEG DMA pid value list
* @rd_mid: JPEG DMA inport read mid value
* @wr_mid: JPEG DMA outport write mid value
*/
struct cam_jpeg_dma_soc_private {
uint32_t num_pid;
uint32_t pid[CAM_JPEG_HW_MAX_NUM_PID];
uint32_t rd_mid;
uint32_t wr_mid;
};
int cam_jpeg_dma_init_soc_resources(struct cam_hw_soc_info *soc_info,
irq_handler_t jpeg_dma_irq_handler, void *irq_data);

47
drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_core.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
*/
#include <linux/of.h>
@ -498,7 +498,9 @@ int cam_jpeg_enc_process_cmd(void *device_priv, uint32_t cmd_type,
{
struct cam_hw_info *jpeg_enc_dev = device_priv;
struct cam_jpeg_enc_device_core_info *core_info = NULL;
int rc;
struct cam_jpeg_match_pid_args *match_pid_mid = NULL;
uint32_t *num_pid = NULL;
int i, rc = 0;
if (!device_priv) {
CAM_ERR(CAM_JPEG, "Invalid arguments");
@ -539,6 +541,47 @@ int cam_jpeg_enc_process_cmd(void *device_priv, uint32_t cmd_type,
cmd_args);
break;
}
case CAM_JPEG_CMD_GET_NUM_PID:
if (!cmd_args) {
CAM_ERR(CAM_JPEG, "cmd args NULL");
return -EINVAL;
}
num_pid = (uint32_t *)cmd_args;
*num_pid = core_info->num_pid;
break;
case CAM_JPEG_CMD_MATCH_PID_MID:
match_pid_mid = (struct cam_jpeg_match_pid_args *)cmd_args;
if (!cmd_args) {
CAM_ERR(CAM_JPEG, "cmd args NULL");
return -EINVAL;
}
for (i = 0 ; i < core_info->num_pid; i++) {
if (core_info->pid[i] == match_pid_mid->pid)
break;
}
if (i == core_info->num_pid)
match_pid_mid->pid_match_found = false;
else
match_pid_mid->pid_match_found = true;
if (match_pid_mid->pid_match_found) {
if (match_pid_mid->fault_mid == core_info->rd_mid) {
match_pid_mid->match_res =
CAM_JPEG_ENC_INPUT_IMAGE;
} else if (match_pid_mid->fault_mid ==
core_info->wr_mid) {
match_pid_mid->match_res =
CAM_JPEG_ENC_OUTPUT_IMAGE;
} else
match_pid_mid->pid_match_found = false;
}
break;
default:
rc = -EINVAL;
break;

6
drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_core.h
View file

@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
*/
#ifndef CAM_JPEG_ENC_CORE_H
@ -66,6 +66,10 @@ struct cam_jpeg_enc_device_core_info {
struct cam_jpeg_set_irq_cb irq_cb;
int32_t ref_count;
struct mutex core_mutex;
uint32_t num_pid;
uint32_t pid[CAM_JPEG_HW_MAX_NUM_PID];
uint32_t rd_mid;
uint32_t wr_mid;
};
int cam_jpeg_enc_init_hw(void *device_priv,

16
drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_dev.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@ -66,8 +66,10 @@ static int cam_jpeg_enc_component_bind(struct device *dev,
const struct of_device_id *match_dev = NULL;
struct cam_jpeg_enc_device_core_info *core_info = NULL;
struct cam_jpeg_enc_device_hw_info *hw_info = NULL;
int rc;
struct platform_device *pdev = to_platform_device(dev);
struct cam_jpeg_enc_soc_private *soc_private;
int i;
int rc;
jpeg_enc_dev_intf = kzalloc(sizeof(struct cam_hw_intf), GFP_KERNEL);
if (!jpeg_enc_dev_intf)
@ -136,6 +138,16 @@ static int cam_jpeg_enc_component_bind(struct device *dev,
init_completion(&jpeg_enc_dev->hw_complete);
CAM_DBG(CAM_JPEG, "JPEG-Encoder component bound successfully");
soc_private = (struct cam_jpeg_enc_soc_private *)
jpeg_enc_dev->soc_info.soc_private;
core_info->num_pid = soc_private->num_pid;
for (i = 0; i < soc_private->num_pid; i++)
core_info->pid[i] = soc_private->pid[i];
core_info->rd_mid = soc_private->rd_mid;
core_info->wr_mid = soc_private->wr_mid;
return rc;
error_reg_cpas:

35
drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_soc.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2019, 2021 The Linux Foundation. All rights reserved.
*/
#include <linux/io.h>
@ -16,8 +16,19 @@
int cam_jpeg_enc_init_soc_resources(struct cam_hw_soc_info *soc_info,
irq_handler_t jpeg_enc_irq_handler, void *irq_data)
{
struct cam_jpeg_enc_soc_private *soc_private;
struct platform_device *pdev = NULL;
int num_pid = 0, i = 0;
int rc;
soc_private = kzalloc(sizeof(struct cam_jpeg_enc_soc_private),
GFP_KERNEL);
if (!soc_private) {
CAM_DBG(CAM_ISP, "Error! soc_private Alloc Failed");
return -ENOMEM;
}
soc_info->soc_private = soc_private;
rc = cam_soc_util_get_dt_properties(soc_info);
if (rc)
return rc;
@ -28,6 +39,28 @@ int cam_jpeg_enc_init_soc_resources(struct cam_hw_soc_info *soc_info,
if (rc)
CAM_ERR(CAM_JPEG, "init soc failed %d", rc);
soc_private->num_pid = 0;
soc_private->rd_mid = UINT_MAX;
soc_private->wr_mid = UINT_MAX;
pdev = soc_info->pdev;
num_pid = of_property_count_u32_elems(pdev->dev.of_node, "cam_hw_pid");
CAM_DBG(CAM_JPEG, "jpeg enc:%d pid count %d", soc_info->index, num_pid);
if (num_pid <= 0 || num_pid > CAM_JPEG_HW_MAX_NUM_PID)
goto end;
soc_private->num_pid = num_pid;
for (i = 0; i < num_pid; i++)
of_property_read_u32_index(pdev->dev.of_node, "cam_hw_pid", i,
&soc_private->pid[i]);
of_property_read_u32(pdev->dev.of_node,
"cam_hw_rd_mid", &soc_private->rd_mid);
of_property_read_u32(pdev->dev.of_node,
"cam_hw_wr_mid", &soc_private->wr_mid);
end:
return rc;
}

20
drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_soc.h
View file

@ -1,12 +1,30 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2018, 2021 The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_JPEG_ENC_SOC_H_
#define _CAM_JPEG_ENC_SOC_H_
#include "cam_soc_util.h"
#include "cam_jpeg_hw_intf.h"
/*
* struct cam_jpeg_enc_soc_private:
*
* @Brief: Private SOC data specific to JPEG ENC Driver
*
* @num_pid JPEG number of pids
* @pid: JPEG enc pid value list
* @rd_mid: JPEG enc inport read mid value
* @wr_mid: JPEG enc outport write mid value
*/
struct cam_jpeg_enc_soc_private {
uint32_t num_pid;
uint32_t pid[CAM_JPEG_HW_MAX_NUM_PID];
uint32_t rd_mid;
uint32_t wr_mid;
};
int cam_jpeg_enc_init_soc_resources(struct cam_hw_soc_info *soc_info,
irq_handler_t jpeg_enc_irq_handler, void *irq_data);