#include <linux/cleanup.h>
#include <linux/cacheflush.h>
#include <linux/pm_runtime.h>
#include "ipu6-bus.h"
#include "ipu6-dma.h"
#include "ipu6-isys.h"
#include "ipu6-platform-regs.h"
#include "ipu7-boot.h"
#include "ipu7-fw-com.h"
#include "ipu7-fw-isys.h"
#include "ipu7-isys-csi2-regs.h"
#include "ipu7-platform-regs.h"
static void ipu7_fw_isys_cleanup(struct ipu6_isys *isys)
{
struct ipu6_bus_device *adev = isys->adev;
struct ipu7_fw_com_context *fwctx = isys->fwctx;
if (!fwctx)
return;
ipu6_ipu7_release_boot_config(adev, fwctx);
if (fwctx->fw_config) {
ipu6_dma_free(adev, sizeof(struct ipu7_insys_config),
fwctx->fw_config, fwctx->fw_config_dma_addr, 0);
fwctx->fw_config = NULL;
fwctx->fw_config_dma_addr = 0;
}
isys->fwctx = NULL;
kfree(fwctx->queue_configs);
kfree(fwctx);
}
static int ipu7_fw_isys_open(struct ipu6_isys *isys)
{
return ipu6_ipu7_boot_start_fw(isys->adev, isys->fwctx);
}
static int ipu7_fw_isys_close(struct ipu6_isys *isys)
{
int ret;
ret = ipu6_ipu7_boot_stop_fw(isys->adev);
if (ret)
return ret;
ipu7_fw_isys_cleanup(isys);
return ret;
}
static int ipu7_fw_isys_init(struct ipu6_isys *isys, unsigned int num_streams)
{
struct ipu7_fw_com_queue_config *queue_configs;
struct ipu6_bus_device *adev = isys->adev;
struct device *dev = &adev->auxdev.dev;
struct ipu7_insys_config *fw_config;
struct ipu7_fw_com_context *fwctx;
dma_addr_t fw_config_dma_addr;
unsigned int num_queues;
u32 freq;
int ret;
fwctx = kzalloc_obj(*fwctx);
if (!fwctx)
return -ENOMEM;
fwctx->num_input_queues = IPU7_INSYS_MAX_INPUT_QUEUES;
fwctx->num_output_queues = IPU7_INSYS_MAX_OUTPUT_QUEUES;
num_queues = fwctx->num_input_queues + fwctx->num_output_queues;
queue_configs = kzalloc_objs(*queue_configs, num_queues);
if (!queue_configs) {
ret = -ENOMEM;
goto err_free_fwctx;
}
fwctx->fw_entry = adev->fw_entry;
fwctx->queue_configs = queue_configs;
queue_configs[IPU7_INSYS_OUTPUT_MSG_QUEUE].max_capacity =
IPU7_ISYS_SIZE_RECV_QUEUE;
queue_configs[IPU7_INSYS_OUTPUT_MSG_QUEUE].token_size_in_bytes =
sizeof(struct ipu7_insys_resp);
queue_configs[IPU7_INSYS_OUTPUT_LOG_QUEUE].max_capacity =
IPU7_ISYS_SIZE_LOG_QUEUE;
queue_configs[IPU7_INSYS_OUTPUT_LOG_QUEUE].token_size_in_bytes =
sizeof(struct ipu7_insys_resp);
queue_configs[IPU7_INSYS_OUTPUT_RESERVED_QUEUE].max_capacity = 0;
queue_configs[IPU7_INSYS_OUTPUT_RESERVED_QUEUE].token_size_in_bytes = 0;
queue_configs[IPU7_INSYS_INPUT_DEV_QUEUE].max_capacity =
IPU7_ISYS_MAX_STREAMS;
queue_configs[IPU7_INSYS_INPUT_DEV_QUEUE].token_size_in_bytes =
sizeof(struct ipu7_insys_send_queue_token);
for (unsigned int i = IPU7_INSYS_INPUT_MSG_QUEUE; i < num_queues; i++) {
queue_configs[i].max_capacity = IPU7_ISYS_SIZE_SEND_QUEUE;
queue_configs[i].token_size_in_bytes =
sizeof(struct ipu7_insys_send_queue_token);
}
fw_config = ipu6_dma_alloc(adev, sizeof(*fw_config),
&fw_config_dma_addr, GFP_KERNEL, 0);
if (!fw_config) {
dev_err(dev, "Failed to allocate isys subsys config.\n");
ret = -ENOMEM;
goto err_free_queue_configs;
}
fwctx->fw_config = fw_config;
fwctx->fw_config_dma_addr = fw_config_dma_addr;
memset(fw_config, 0, sizeof(*fw_config));
fw_config->logger_config.use_source_severity = 0;
fw_config->logger_config.use_channels_enable_bitmask = 1;
fw_config->logger_config.channels_enable_bitmask =
IPU7_LOGGER_CFG_CHANNEL_ENABLE_SYSCOM;
fw_config->logger_config.hw_printf_buffer_base_addr = 0U;
fw_config->logger_config.hw_printf_buffer_size_bytes = 0U;
fw_config->wdt_config.wdt_timer1_us = 0;
fw_config->wdt_config.wdt_timer2_us = 0;
freq = ipu7_buttress_get_isys_freq(adev->isp);
ipu6_dma_sync_single(adev, fw_config_dma_addr,
sizeof(struct ipu7_insys_config));
isys->fwctx = fwctx;
ret = ipu6_ipu7_init_boot_config(adev, fwctx, queue_configs,
num_queues, freq, fw_config_dma_addr,
IS_IPU8(adev->isp) ? 2U : 1U);
if (ret) {
ipu7_fw_isys_cleanup(isys);
return ret;
}
ret = ipu7_fw_isys_open(isys);
if (ret)
ipu7_fw_isys_cleanup(isys);
return ret;
err_free_queue_configs:
kfree(queue_configs);
err_free_fwctx:
kfree(fwctx);
return ret;
}
static struct ipu7_insys_resp *ipu7_fw_isys_get_resp(struct ipu6_isys *isys)
{
return ipu7_fw_com_get_token(isys->fwctx, IPU7_INSYS_OUTPUT_MSG_QUEUE);
}
static void ipu7_fw_isys_put_resp(struct ipu6_isys *isys)
{
ipu7_fw_com_put_token(isys->fwctx, IPU7_INSYS_OUTPUT_MSG_QUEUE);
}
static int ipu7_isys_fw_pin_cfg(struct ipu6_isys_video *av,
struct ipu6_isys_stream *stream,
struct media_pad *src_pad,
struct v4l2_mbus_frame_desc_entry *entry,
void *__cfg)
{
struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(src_pad->entity);
struct v4l2_subdev_state *state = v4l2_subdev_get_locked_active_state(sd);
struct ipu7_fw_isys_stream_cfg *cfg = __cfg;
struct ipu7_fw_isys_input_pin *input_pin;
struct ipu7_fw_isys_output_pin *output_pin;
struct ipu6_isys_queue *aq = &av->aq;
struct v4l2_mbus_framefmt *fmt;
const struct ipu6_isys_pixelformat *pfmt =
ipu6_isys_get_isys_format(ipu6_isys_get_format(av), 0);
int input_pins = cfg->nof_input_pins++;
int output_pins;
u32 src_stream;
src_stream = __ipu6_isys_get_src_stream_by_src_pad(state, src_pad->index);
fmt = v4l2_subdev_state_get_format(state, src_pad->index, src_stream);
input_pin = &cfg->input_pins[input_pins];
input_pin->input_res.width = fmt->width;
input_pin->input_res.height = fmt->height;
input_pin->dt = entry->bus.csi2.dt;
input_pin->disable_mipi_unpacking = 0;
if (pfmt->bpp == pfmt->bpp_packed && pfmt->bpp % BITS_PER_BYTE)
input_pin->disable_mipi_unpacking = 1;
input_pin->mapped_dt = IPU7_N_INSYS_MIPI_DATA_TYPE;
input_pin->dt_rename_mode = IPU7_INSYS_MIPI_DT_NO_RENAME;
input_pin->sync_msg_map =
IPU7_INSYS_STREAM_SYNC_MSG_SEND_RESP_SOF |
IPU7_INSYS_STREAM_SYNC_MSG_SEND_RESP_SOF_DISCARDED |
IPU7_INSYS_STREAM_SYNC_MSG_SEND_IRQ_SOF |
IPU7_INSYS_STREAM_SYNC_MSG_SEND_IRQ_SOF_DISCARDED;
output_pins = cfg->nof_output_pins++;
aq->fw_output = output_pins;
av->stream->output_pins_queue[output_pins] = aq;
output_pin = &cfg->output_pins[output_pins];
memset(output_pin, 0, sizeof(*output_pin));
output_pin->link.buffer_lines = 0;
output_pin->link.foreign_key = IPU7_MSG_LINK_FOREIGN_KEY_NONE;
output_pin->link.pbk_id = IPU7_MSG_LINK_PBK_ID_DONT_CARE;
output_pin->link.pbk_slot_id = IPU7_MSG_LINK_PBK_SLOT_ID_DONT_CARE;
output_pin->link.dest = 0;
output_pin->link.use_sw_managed = 1;
output_pin->crop.line_top = 0;
output_pin->crop.line_bottom = 0;
output_pin->dpcm.enable = 0;
output_pin->ft = pfmt->css_pixelformat;
output_pin->stride = ipu6_isys_get_bytes_per_line(av);
output_pin->send_irq = 1;
output_pin->input_pin_id = input_pins;
return 0;
}
static int
ipu7_fw_isys_send_cmd(struct ipu6_isys *isys, const unsigned int stream_handle,
void *cpu_mapped_buf, dma_addr_t dma_mapped_buf,
size_t size, u16 send_type)
{
struct ipu7_fw_com_context *ctx = isys->fwctx;
struct ipu7_insys_send_queue_token *token;
if (send_type >= N_IPU7_INSYS_SEND_TYPE)
return -EINVAL;
if (cpu_mapped_buf)
clflush_cache_range(cpu_mapped_buf, size);
token = ipu7_fw_com_get_token(ctx, stream_handle +
IPU7_INSYS_INPUT_MSG_QUEUE);
if (!token)
return -EBUSY;
token->addr = dma_mapped_buf;
token->buf_handle = (unsigned long)cpu_mapped_buf;
token->send_type = send_type;
token->stream_id = stream_handle;
token->flag = IPU7_INSYS_SEND_QUEUE_TOKEN_FLAG_NONE;
ipu7_fw_com_put_token(ctx, stream_handle + IPU7_INSYS_INPUT_MSG_QUEUE);
ipu7_buttress_wakeup_isys(isys->adev->isp);
return 0;
}
static void ipu7_fw_isys_dump_stream_cfg(struct device *dev,
struct isys_fw_msgs *msg)
{
struct ipu7_fw_isys_stream_cfg *cfg = &msg->ipu7.stream;
unsigned int i;
dev_dbg(dev, "---------------------------\n");
dev_dbg(dev, "IPU_FW_ISYS_STREAM_CFG_DATA\n");
dev_dbg(dev, ".port id %d\n", cfg->port_id);
dev_dbg(dev, ".vc %d\n", cfg->vc);
dev_dbg(dev, ".nof_input_pins = %d\n", cfg->nof_input_pins);
dev_dbg(dev, ".nof_output_pins = %d\n", cfg->nof_output_pins);
dev_dbg(dev, ".stream_msg_map = 0x%x\n", cfg->stream_msg_map);
for (i = 0; i < cfg->nof_input_pins; i++) {
dev_dbg(dev, ".input_pin[%d]:\n", i);
dev_dbg(dev, "\t.dt = 0x%0x\n",
cfg->input_pins[i].dt);
dev_dbg(dev, "\t.disable_mipi_unpacking = %d\n",
cfg->input_pins[i].disable_mipi_unpacking);
dev_dbg(dev, "\t.dt_rename_mode = %d\n",
cfg->input_pins[i].dt_rename_mode);
dev_dbg(dev, "\t.mapped_dt = 0x%0x\n",
cfg->input_pins[i].mapped_dt);
dev_dbg(dev, "\t.input_res = %d x %d\n",
cfg->input_pins[i].input_res.width,
cfg->input_pins[i].input_res.height);
dev_dbg(dev, "\t.sync_msg_map = 0x%x\n",
cfg->input_pins[i].sync_msg_map);
}
for (i = 0; i < cfg->nof_output_pins; i++) {
dev_dbg(dev, ".output_pin[%d]:\n", i);
dev_dbg(dev, "\t.input_pin_id = %d\n",
cfg->output_pins[i].input_pin_id);
dev_dbg(dev, "\t.stride = %d\n", cfg->output_pins[i].stride);
dev_dbg(dev, "\t.send_irq = %d\n",
cfg->output_pins[i].send_irq);
dev_dbg(dev, "\t.ft = %d\n", cfg->output_pins[i].ft);
dev_dbg(dev, "\t.link.buffer_lines = %d\n",
cfg->output_pins[i].link.buffer_lines);
dev_dbg(dev, "\t.link.foreign_key = %d\n",
cfg->output_pins[i].link.foreign_key);
dev_dbg(dev, "\t.link.granularity_pointer_update = %d\n",
cfg->output_pins[i].link.granularity_pointer_update);
dev_dbg(dev, "\t.link.msg_link_streaming_mode = %d\n",
cfg->output_pins[i].link.msg_link_streaming_mode);
dev_dbg(dev, "\t.link.pbk_id = %d\n",
cfg->output_pins[i].link.pbk_id);
dev_dbg(dev, "\t.link.pbk_slot_id = %d\n",
cfg->output_pins[i].link.pbk_slot_id);
dev_dbg(dev, "\t.link.dest = %d\n",
cfg->output_pins[i].link.dest);
dev_dbg(dev, "\t.link.use_sw_managed = %d\n",
cfg->output_pins[i].link.use_sw_managed);
dev_dbg(dev, "\t.link.is_snoop = %d\n",
cfg->output_pins[i].link.is_snoop);
dev_dbg(dev, "\t.crop.line_top = %d\n",
cfg->output_pins[i].crop.line_top);
dev_dbg(dev, "\t.crop.line_bottom = %d\n",
cfg->output_pins[i].crop.line_bottom);
dev_dbg(dev, "\t.dpcm_enable = %d\n",
cfg->output_pins[i].dpcm.enable);
dev_dbg(dev, "\t.dpcm.type = %d\n",
cfg->output_pins[i].dpcm.type);
dev_dbg(dev, "\t.dpcm.predictor = %d\n",
cfg->output_pins[i].dpcm.predictor);
}
dev_dbg(dev, "---------------------------\n");
}
static void ipu7_fw_isys_dump_frame_buf_set(struct device *dev,
struct isys_fw_msgs *msg,
unsigned int outputs)
{
struct ipu7_fw_isys_frame_buff_set *buf = &msg->ipu7.frame;
dev_dbg(dev, "--------------------------\n");
dev_dbg(dev, "IPU_ISYS_BUFF_SET\n");
dev_dbg(dev, ".capture_msg_map = %d\n", buf->capture_msg_map);
dev_dbg(dev, ".frame_id = %d\n", buf->frame_id);
dev_dbg(dev, ".skip_frame = %d\n", buf->skip_frame);
for (unsigned int i = 0; i < outputs; i++) {
dev_dbg(dev, ".output_pin[%d]:\n", i);
dev_dbg(dev, "\t.user_token = %llx\n",
buf->output_pins[i].user_token);
dev_dbg(dev, "\t.addr = 0x%x\n", buf->output_pins[i].addr);
}
dev_dbg(dev, "---------------------------\n");
}
static int ipu7_fw_isys_prepare_stream_cfg(struct ipu6_isys_stream *stream,
struct v4l2_mbus_frame_desc *desc,
struct isys_fw_msgs *msg)
{
struct ipu7_fw_isys_stream_cfg *cfg = &msg->ipu7.stream;
struct device *dev = &stream->isys->adev->auxdev.dev;
int ret;
memset(cfg, 0, sizeof(*cfg));
cfg->port_id = stream->asd->source;
cfg->vc = stream->vc;
cfg->stream_msg_map = IPU7_INSYS_STREAM_ENABLE_MSG_SEND_RESP |
IPU7_INSYS_STREAM_ENABLE_MSG_SEND_IRQ;
ret = ipu6_isys_fw_pins_prepare(stream, desc, ipu7_isys_fw_pin_cfg,
cfg);
if (ret)
return ret;
stream->nr_output_pins = cfg->nof_output_pins;
ipu7_fw_isys_dump_stream_cfg(dev, msg);
return 0;
}
static void
ipu7_isys_buf_to_fw_frame_buf_pin(struct vb2_buffer *vb,
struct ipu7_fw_isys_frame_buff_set *set)
{
struct ipu6_isys_queue *aq = vb2_queue_to_isys_queue(vb->vb2_queue);
struct vb2_v4l2_buffer *vvb = to_vb2_v4l2_buffer(vb);
struct ipu6_isys_video_buffer *ivb =
vb2_buffer_to_ipu6_isys_video_buffer(vvb);
set->output_pins[aq->fw_output].addr = ivb->dma_addr;
set->output_pins[aq->fw_output].user_token = (u64)(uintptr_t)set;
}
static void
ipu7_fw_isys_prepare_buf_set(struct isys_fw_msgs *msg,
struct ipu6_isys_stream *stream,
struct ipu6_isys_buffer_list *bl)
{
struct ipu7_fw_isys_frame_buff_set *set = &msg->ipu7.frame;
struct ipu6_isys_buffer *ib;
WARN_ON(!bl->nbufs);
memset(set, 0, sizeof(*set));
set->capture_msg_map = IPU7_INSYS_FRAME_ENABLE_MSG_SEND_RESP |
IPU7_INSYS_FRAME_ENABLE_MSG_SEND_IRQ;
set->frame_id = atomic_fetch_inc(&stream->buf_id) % 256;
list_for_each_entry(ib, &bl->head, head) {
struct vb2_buffer *vb = ipu6_isys_buffer_to_vb2_buffer(ib);
ipu7_isys_buf_to_fw_frame_buf_pin(vb, set);
}
dev_dbg(&stream->isys->adev->auxdev.dev,
"ipu7 frame_buf: cap_map=0x%x fid=%u opin[0].addr=0x%x token=0x%llx\n",
set->capture_msg_map, set->frame_id,
set->output_pins[0].addr, set->output_pins[0].user_token);
}
static void isys_stream_cfg_to_ipu8(struct ipu7_fw_isys_stream_cfg_ipu8 *dst,
const struct ipu7_fw_isys_stream_cfg *src)
{
memset(dst, 0, sizeof(*dst));
memcpy(dst->input_pins, src->input_pins, sizeof(dst->input_pins));
dst->stream_msg_map = src->stream_msg_map;
dst->port_id = src->port_id;
dst->vc = src->vc;
dst->nof_input_pins = src->nof_input_pins;
dst->nof_output_pins = src->nof_output_pins;
for (unsigned int i = 0; i < ARRAY_SIZE(src->output_pins); i++) {
dst->output_pins[i].link = src->output_pins[i].link;
dst->output_pins[i].crop.line_top =
src->output_pins[i].crop.line_top;
dst->output_pins[i].crop.line_bottom =
src->output_pins[i].crop.line_bottom;
dst->output_pins[i].dpcm = src->output_pins[i].dpcm;
dst->output_pins[i].stride = src->output_pins[i].stride;
dst->output_pins[i].ft = src->output_pins[i].ft;
dst->output_pins[i].send_irq = src->output_pins[i].send_irq;
dst->output_pins[i].input_pin_id =
src->output_pins[i].input_pin_id;
dst->output_pins[i].early_ack_en =
src->output_pins[i].early_ack_en;
}
}
static void isys_buffset_to_ipu8(struct ipu7_fw_isys_frame_buff_set_ipu8 *dst,
const struct ipu7_fw_isys_frame_buff_set *src)
{
memset(dst, 0, sizeof(*dst));
for (unsigned int i = 0; i < ARRAY_SIZE(src->output_pins); i++)
dst->output_pins[i].pin_payload = src->output_pins[i];
dst->capture_msg_map = src->capture_msg_map;
dst->frame_id = src->frame_id;
dst->skip_frame = src->skip_frame;
}
static int ipu7_fw_isys_stream_open(struct ipu6_isys *isys,
const unsigned int stream_handle,
struct isys_fw_msgs *msg)
{
if (IS_IPU8(isys->adev->isp)) {
struct ipu7_fw_isys_stream_cfg cfg = msg->ipu7.stream;
isys_stream_cfg_to_ipu8(&msg->ipu7.stream_ipu8, &cfg);
return ipu7_fw_isys_send_cmd(isys, stream_handle,
&msg->ipu7.stream_ipu8,
msg->dma_addr,
sizeof(msg->ipu7.stream_ipu8),
IPU7_INSYS_SEND_TYPE_STREAM_OPEN);
}
return ipu7_fw_isys_send_cmd(isys, stream_handle, &msg->ipu7.stream,
msg->dma_addr, sizeof(msg->ipu7.stream),
IPU7_INSYS_SEND_TYPE_STREAM_OPEN);
}
static int ipu7_fw_isys_stream_close(struct ipu6_isys *isys,
const unsigned int stream_handle)
{
return ipu7_fw_isys_send_cmd(isys, stream_handle, NULL, 0, 0,
IPU7_INSYS_SEND_TYPE_STREAM_CLOSE);
}
static int ipu7_fw_isys_stream_flush(struct ipu6_isys *isys,
const unsigned int stream_handle)
{
return ipu7_fw_isys_send_cmd(isys, stream_handle, NULL, 0, 0,
IPU7_INSYS_SEND_TYPE_STREAM_FLUSH);
}
static int ipu7_fw_isys_send_frame_buff_set(struct ipu6_isys *isys,
const unsigned int stream_handle,
struct isys_fw_msgs *msg, u16 send_type)
{
if (IS_IPU8(isys->adev->isp)) {
struct ipu7_fw_isys_frame_buff_set set = msg->ipu7.frame;
isys_buffset_to_ipu8(&msg->ipu7.frame_ipu8, &set);
return ipu7_fw_isys_send_cmd(isys, stream_handle,
&msg->ipu7.frame_ipu8,
msg->dma_addr,
sizeof(msg->ipu7.frame_ipu8),
send_type);
}
return ipu7_fw_isys_send_cmd(isys, stream_handle, &msg->ipu7.frame,
msg->dma_addr, sizeof(msg->ipu7.frame),
send_type);
}
static int ipu7_fw_isys_stream_start(struct ipu6_isys *isys,
const unsigned int stream_handle,
struct isys_fw_msgs *msg, bool capture)
{
return ipu7_fw_isys_send_frame_buff_set(isys, stream_handle, msg,
IPU7_INSYS_SEND_TYPE_STREAM_START_AND_CAPTURE);
}
static int ipu7_fw_isys_stream_capture(struct ipu6_isys *isys,
const unsigned int stream_handle,
struct isys_fw_msgs *msg)
{
return ipu7_fw_isys_send_frame_buff_set(isys, stream_handle, msg,
IPU7_INSYS_SEND_TYPE_STREAM_CAPTURE);
}
const struct ipu6_fw_isys_ops ipu7_fw_isys_ops = {
.init = ipu7_fw_isys_init,
.close = ipu7_fw_isys_close,
.send_cmd = ipu7_fw_isys_send_cmd,
.cleanup = ipu7_fw_isys_cleanup,
.prepare_stream_cfg = ipu7_fw_isys_prepare_stream_cfg,
.prepare_buf_set = ipu7_fw_isys_prepare_buf_set,
.stream_open = ipu7_fw_isys_stream_open,
.stream_start = ipu7_fw_isys_stream_start,
.stream_capture = ipu7_fw_isys_stream_capture,
.stream_flush = ipu7_fw_isys_stream_flush,
.stream_close = ipu7_fw_isys_stream_close,
.dump_stream_cfg = ipu7_fw_isys_dump_stream_cfg,
.dump_frame_buf_set = ipu7_fw_isys_dump_frame_buf_set,
};
static const struct ipu7_csi2_error {
const char *error_string;
bool is_info_only;
} dphy_rx_errors[] = {
{ "Error handler FIFO full", false },
{ "Reserved Short Packet encoding detected", true },
{ "Reserved Long Packet encoding detected", true },
{ "Received packet is too short", false},
{ "Received packet is too long", false},
{ "Short packet discarded due to errors", false },
{ "Long packet discarded due to errors", false },
{ "CSI Combo Rx interrupt", false },
{ "IDI CDC FIFO overflow(remaining bits are reserved as 0)", false },
{ "Received NULL packet", true },
{ "Received blanking packet", true },
{ "Tie to 0", true },
};
static void ipu7_isys_register_errors(struct ipu6_isys_csi2 *csi2)
{
u32 offset = IPU7_IS_IO_CSI2_ERR_LEGACY_IRQ_CTL_BASE(csi2->port);
u32 status = readl(csi2->base + offset + IPU7_IRQ_CTL_STATUS);
u32 mask = IPU7_CSI_RX_ERROR_IRQ_MASK;
if (!status)
return;
dev_dbg(&csi2->isys->adev->auxdev.dev, "csi2-%u error status 0x%08x\n",
csi2->port, status);
writel(status & mask, csi2->base + offset + IPU7_IRQ_CTL_CLEAR);
csi2->receiver_errors |= status & mask;
}
static void ipu7_isys_csi2_error(struct ipu6_isys_csi2 *csi2)
{
u32 status;
ipu7_isys_register_errors(csi2);
status = csi2->receiver_errors;
csi2->receiver_errors = 0;
for (unsigned int i = 0; i < ARRAY_SIZE(dphy_rx_errors); i++) {
if (status & BIT(i))
dev_err_ratelimited(&csi2->isys->adev->auxdev.dev,
"csi2-%i error: %s\n",
csi2->port,
dphy_rx_errors[i].error_string);
}
}
static const struct resp_to_msg {
enum ipu7_insys_resp_type type;
const char *msg;
} is_fw_msg[] = {
{ IPU7_INSYS_RESP_TYPE_STREAM_OPEN_DONE, "STREAM_OPEN_DONE" },
{ IPU7_INSYS_RESP_TYPE_STREAM_START_AND_CAPTURE_ACK,
"STREAM_START_AND_CAPTURE_ACK" },
{ IPU7_INSYS_RESP_TYPE_STREAM_CAPTURE_ACK, "STREAM_CAPTURE_ACK" },
{ IPU7_INSYS_RESP_TYPE_STREAM_ABORT_ACK, "STREAM_ABORT_ACK" },
{ IPU7_INSYS_RESP_TYPE_STREAM_FLUSH_ACK, "STREAM_FLUSH_ACK" },
{ IPU7_INSYS_RESP_TYPE_STREAM_CLOSE_ACK, "STREAM_CLOSE_ACK" },
{ IPU7_INSYS_RESP_TYPE_PIN_DATA_READY, "PIN_DATA_READY" },
{ IPU7_INSYS_RESP_TYPE_FRAME_SOF, "FRAME_SOF" },
{ IPU7_INSYS_RESP_TYPE_FRAME_EOF, "FRAME_EOF" },
{ IPU7_INSYS_RESP_TYPE_STREAM_START_AND_CAPTURE_DONE,
"STREAM_START_AND_CAPTURE_DONE" },
{ IPU7_INSYS_RESP_TYPE_STREAM_CAPTURE_DONE, "STREAM_CAPTURE_DONE" },
{ N_IPU7_INSYS_RESP_TYPE, "N_IPU7_INSYS_RESP_TYPE" },
};
static int ipu7_isys_isr_one(struct ipu6_bus_device *adev)
{
struct ipu6_isys *isys = ipu6_bus_get_drvdata(adev);
struct ipu6_isys_stream *stream = NULL;
struct device *dev = &adev->auxdev.dev;
struct ipu6_isys_csi2 *csi2 = NULL;
struct ipu7_fw_isys_msg_err err_info;
struct isys_fw_msgs *isys_fw_msg;
struct ipu7_insys_resp *resp;
unsigned long flags;
u64 ts;
resp = ipu7_fw_isys_get_resp(isys);
if (!resp)
return 1;
if (resp->type >= N_IPU7_INSYS_RESP_TYPE) {
dev_err(dev, "Unknown response type %u stream %u\n",
resp->type, resp->stream_id);
ipu7_fw_isys_put_resp(isys);
return 1;
}
err_info = resp->error_info;
ts = ((u64)resp->timestamp[1] << 32) | resp->timestamp[0];
if (err_info.err_group == INSYS_MSG_ERR_GROUP_CAPTURE &&
err_info.err_code == INSYS_MSG_ERR_CAPTURE_SYNC_FRAME_DROP) {
dev_dbg(dev, "FRAME DROP: %02u %s stream %u\n",
resp->type, is_fw_msg[resp->type].msg,
resp->stream_id);
dev_dbg(dev, "\tpin %u buf_id %llx frame %u\n",
resp->pin_id, resp->buf_id, resp->frame_id);
dev_dbg(dev, "\terror group %u code %u details [%u %u]\n",
err_info.err_group, err_info.err_code,
err_info.err_detail[0], err_info.err_detail[1]);
} else if (err_info.err_code) {
dev_err(dev, "%02u %s stream %u pin %u buf_id %llx frame %u\n",
resp->type, is_fw_msg[resp->type].msg, resp->stream_id,
resp->pin_id, resp->buf_id, resp->frame_id);
dev_err(dev, "\terror group %u code %u details [%u %u]\n",
err_info.err_group, err_info.err_code,
err_info.err_detail[0], err_info.err_detail[1]);
} else {
dev_dbg(dev, "%02u %s stream %u pin %u buf_id %llx frame %u\n",
resp->type, is_fw_msg[resp->type].msg, resp->stream_id,
resp->pin_id, resp->buf_id, resp->frame_id);
dev_dbg(dev, "\tts %llu\n", ts);
}
if (resp->stream_id >= IPU7_ISYS_MAX_STREAMS) {
dev_err(dev, "bad stream handle %u\n",
resp->stream_id);
goto leave_nounlock;
}
spin_lock_irqsave(&isys->streams_lock, flags);
stream = resp->stream_id < IPU6_ISYS_MAX_STREAMS ?
isys->streams_by_handle[resp->stream_id] : NULL;
if (!stream) {
dev_err(dev, "stream of stream_handle %u is unused\n",
resp->stream_id);
goto leave;
}
stream->error = err_info.err_code;
if (stream->asd)
csi2 = ipu6_isys_subdev_to_csi2(stream->asd);
switch (resp->type) {
case IPU7_INSYS_RESP_TYPE_STREAM_OPEN_DONE:
complete(&stream->stream_open_completion);
break;
case IPU7_INSYS_RESP_TYPE_STREAM_CLOSE_ACK:
complete(&stream->stream_close_completion);
break;
case IPU7_INSYS_RESP_TYPE_STREAM_START_AND_CAPTURE_ACK:
complete(&stream->stream_start_completion);
break;
case IPU7_INSYS_RESP_TYPE_STREAM_ABORT_ACK:
complete(&stream->stream_stop_completion);
break;
case IPU7_INSYS_RESP_TYPE_STREAM_FLUSH_ACK:
complete(&stream->stream_stop_completion);
break;
case IPU7_INSYS_RESP_TYPE_PIN_DATA_READY:
isys_fw_msg = container_of((void *)(uintptr_t)resp->buf_id,
struct isys_fw_msgs, dummy);
ipu6_put_fw_msg_buf(ipu6_bus_get_drvdata(adev), isys_fw_msg);
if (resp->pin_id < IPU6_ISYS_OUTPUT_PINS &&
stream->output_pins_queue[resp->pin_id])
ipu6_stream_buf_ready(stream, resp->pin_id,
resp->pin.addr, ts, 0);
else
dev_err(dev, "No handler for pin %u ready\n",
resp->pin_id);
if (csi2)
ipu7_isys_csi2_error(csi2);
break;
case IPU7_INSYS_RESP_TYPE_STREAM_CAPTURE_ACK:
break;
case IPU7_INSYS_RESP_TYPE_STREAM_START_AND_CAPTURE_DONE:
case IPU7_INSYS_RESP_TYPE_STREAM_CAPTURE_DONE:
break;
case IPU7_INSYS_RESP_TYPE_FRAME_SOF:
if (csi2)
ipu6_isys_csi2_sof_event_by_stream(stream);
stream->seq[stream->seq_index].sequence =
atomic_read(&stream->sequence) - 1U;
stream->seq[stream->seq_index].timestamp = ts;
dev_dbg(dev,
"SOF: stream %u frame %u (index %u), ts 0x%16.16llx\n",
resp->stream_id, resp->frame_id,
stream->seq[stream->seq_index].sequence, ts);
stream->seq_index = (stream->seq_index + 1U)
% IPU6_ISYS_MAX_PARALLEL_SOF;
break;
case IPU7_INSYS_RESP_TYPE_FRAME_EOF:
if (csi2)
ipu6_isys_csi2_eof_event_by_stream(stream);
dev_dbg(dev, "eof: stream %d(index %u) ts 0x%16.16llx\n",
resp->stream_id,
stream->seq[stream->seq_index].sequence, ts);
break;
default:
dev_err(dev, "Unknown response type %u stream %u\n",
resp->type, resp->stream_id);
break;
}
leave:
spin_unlock_irqrestore(&isys->streams_lock, flags);
leave_nounlock:
ipu7_fw_isys_put_resp(isys);
return 0;
}
#define IPU7_NR_OF_CSI2_VC 16U
static void ipu7_isys_csi2_isr(struct ipu6_isys_csi2 *csi2)
{
struct device *dev = &csi2->isys->adev->auxdev.dev;
struct ipu6_device *isp = csi2->isys->adev->isp;
struct ipu6_isys_stream *s;
u32 sync, offset;
u32 fe = 0;
u8 vc;
ipu7_isys_register_errors(csi2);
offset = IPU7_IS_IO_CSI2_SYNC_LEGACY_IRQ_CTL_BASE(csi2->port);
sync = readl(csi2->base + offset + IPU7_IRQ_CTL_STATUS);
writel(sync, csi2->base + offset + IPU7_IRQ_CTL_CLEAR);
dev_dbg(dev, "csi2-%u sync status 0x%08x\n", csi2->port, sync);
if (!IS_IPU7_MTL(isp)) {
fe = readl(csi2->base + offset + IPU7_IRQ1_CTL_STATUS);
writel(fe, csi2->base + offset + IPU7_IRQ1_CTL_CLEAR);
dev_dbg(dev, "csi2-%u FE status 0x%08x\n", csi2->port, fe);
}
for (vc = 0; vc < IPU7_NR_OF_CSI2_VC && (sync || fe); vc++) {
s = csi2->streams_by_vc[vc];
if (!s)
continue;
if (!IS_IPU7_MTL(isp)) {
if (sync & IPU7P5_CSI_RX_SYNC_FS_VC & (1U << vc))
ipu6_isys_csi2_sof_event_by_stream(s);
if (fe & IPU7P5_CSI_RX_SYNC_FE_VC & (1U << vc))
ipu6_isys_csi2_eof_event_by_stream(s);
} else {
if (sync & IPU7_CSI_RX_SYNC_FS_VC & (1U << (vc * 2)))
ipu6_isys_csi2_sof_event_by_stream(s);
if (sync & IPU7_CSI_RX_SYNC_FE_VC & (2U << (vc * 2)))
ipu6_isys_csi2_eof_event_by_stream(s);
}
}
}
static void ipu7_dispatch_csi2_isr(struct ipu6_isys *isys, u32 status)
{
for (unsigned int i = 0; i < isys->pdata->ipdata->csi2.nports; i++) {
if (!isys->csi2[i].base)
continue;
if (status & isys->csi2[i].legacy_irq_mask)
ipu7_isys_csi2_isr(&isys->csi2[i]);
}
}
irqreturn_t ipu7_isys_isr(struct ipu6_bus_device *adev)
{
struct ipu6_isys *isys = ipu6_bus_get_drvdata(adev);
void __iomem *base = isys->pdata->base;
u32 status_sw, status_csi;
u32 csi_offset, sw_offset;
int pm_status;
pm_status = pm_runtime_get_if_active(&adev->auxdev.dev);
if (!pm_status)
return 0;
csi_offset = IPU7_IS_IO_CSI2_LEGACY_IRQ_CTRL_BASE;
sw_offset = IPU7_IS_UC_CTRL_BASE;
status_csi = readl(base + csi_offset + IPU7_IRQ_CTL_STATUS);
status_sw = readl(base + sw_offset + IPU7_TO_SW_IRQ_CNTL_STATUS);
if (!status_csi && !status_sw) {
if (pm_status > 0)
pm_runtime_put(&adev->auxdev.dev);
return IRQ_NONE;
}
do {
writel(status_sw, base + sw_offset + IPU7_TO_SW_IRQ_CNTL_CLEAR);
writel(status_csi, base + csi_offset + IPU7_IRQ_CTL_CLEAR);
if (isys->isr_csi2_bits & status_csi)
ipu7_dispatch_csi2_isr(isys, status_csi);
if (!ipu7_isys_isr_one(adev))
status_sw = IPU7_TO_SW_IRQ_FW;
else
status_sw = 0;
status_csi = readl(base + csi_offset + IPU7_IRQ_CTL_STATUS);
status_sw |= readl(base + sw_offset +
IPU7_TO_SW_IRQ_CNTL_STATUS);
} while ((status_csi & isys->isr_csi2_bits) ||
(status_sw & IPU7_TO_SW_IRQ_FW));
writel(IPU7_IS_UC_TO_SW_IRQ_MASK,
base + sw_offset + IPU7_TO_SW_IRQ_CNTL_MASK_N);
if (pm_status > 0)
pm_runtime_put(&adev->auxdev.dev);
return IRQ_HANDLED;
}