| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Copyright 2020-2021 NXP | |
| */ | |
| #include <linux/init.h> | |
| #include <linux/interconnect.h> | |
| #include <linux/ioctl.h> | |
| #include <linux/list.h> | |
| #include <linux/kernel.h> | |
| #include <linux/module.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/slab.h> | |
| #include <linux/types.h> | |
| #include <linux/delay.h> | |
| #include "vpu.h" | |
| #include "vpu_defs.h" | |
| #include "vpu_cmds.h" | |
| #include "vpu_rpc.h" | |
| #include "vpu_mbox.h" | |
| struct vpu_cmd_request { | |
| u32 request; | |
| u32 response; | |
| u32 handled; | |
| }; | |
| struct vpu_cmd_t { | |
| struct list_head list; | |
| u32 id; | |
| struct vpu_cmd_request *request; | |
| struct vpu_rpc_event *pkt; | |
| unsigned long key; | |
| atomic_long_t *last_response_cmd; | |
| }; | |
| static struct vpu_cmd_request vpu_cmd_requests[] = { | |
| { | |
| .request = VPU_CMD_ID_CONFIGURE_CODEC, | |
| .response = VPU_MSG_ID_MEM_REQUEST, | |
| .handled = 1, | |
| }, | |
| { | |
| .request = VPU_CMD_ID_START, | |
| .response = VPU_MSG_ID_START_DONE, | |
| .handled = 0, | |
| }, | |
| { | |
| .request = VPU_CMD_ID_STOP, | |
| .response = VPU_MSG_ID_STOP_DONE, | |
| .handled = 0, | |
| }, | |
| { | |
| .request = VPU_CMD_ID_ABORT, | |
| .response = VPU_MSG_ID_ABORT_DONE, | |
| .handled = 0, | |
| }, | |
| { | |
| .request = VPU_CMD_ID_RST_BUF, | |
| .response = VPU_MSG_ID_BUF_RST, | |
| .handled = 1, | |
| }, | |
| }; | |
| static int vpu_cmd_send(struct vpu_core *core, struct vpu_rpc_event *pkt) | |
| { | |
| int ret = 0; | |
| ret = vpu_iface_send_cmd(core, pkt); | |
| if (ret) | |
| return ret; | |
| /*write cmd data to cmd buffer before trigger a cmd interrupt*/ | |
| mb(); | |
| vpu_mbox_send_type(core, COMMAND); | |
| return ret; | |
| } | |
| static struct vpu_cmd_t *vpu_alloc_cmd(struct vpu_inst *inst, u32 id, void *data) | |
| { | |
| struct vpu_cmd_t *cmd; | |
| int i; | |
| int ret; | |
| cmd = kzalloc_obj(*cmd); | |
| if (!cmd) | |
| return NULL; | |
| cmd->pkt = kzalloc_obj(*cmd->pkt); | |
| if (!cmd->pkt) { | |
| kfree(cmd); | |
| return NULL; | |
| } | |
| cmd->id = id; | |
| ret = vpu_iface_pack_cmd(inst->core, cmd->pkt, inst->id, id, data); | |
| if (ret) { | |
| dev_err(inst->dev, "iface pack cmd %s fail\n", vpu_id_name(id)); | |
| kfree(cmd->pkt); | |
| kfree(cmd); | |
| return NULL; | |
| } | |
| for (i = 0; i < ARRAY_SIZE(vpu_cmd_requests); i++) { | |
| if (vpu_cmd_requests[i].request == id) { | |
| cmd->request = &vpu_cmd_requests[i]; | |
| break; | |
| } | |
| } | |
| return cmd; | |
| } | |
| static void vpu_free_cmd(struct vpu_cmd_t *cmd) | |
| { | |
| if (!cmd) | |
| return; | |
| if (cmd->last_response_cmd) | |
| atomic_long_set(cmd->last_response_cmd, cmd->key); | |
| kfree(cmd->pkt); | |
| kfree(cmd); | |
| } | |
| static int vpu_session_process_cmd(struct vpu_inst *inst, struct vpu_cmd_t *cmd) | |
| { | |
| int ret; | |
| dev_dbg(inst->dev, "[%d]send cmd %s\n", inst->id, vpu_id_name(cmd->id)); | |
| vpu_iface_pre_send_cmd(inst); | |
| ret = vpu_cmd_send(inst->core, cmd->pkt); | |
| if (!ret) { | |
| vpu_iface_post_send_cmd(inst); | |
| vpu_inst_record_flow(inst, cmd->id); | |
| } else { | |
| dev_err(inst->dev, "[%d] iface send cmd %s fail\n", inst->id, vpu_id_name(cmd->id)); | |
| } | |
| return ret; | |
| } | |
| static void vpu_process_cmd_request(struct vpu_inst *inst) | |
| { | |
| struct vpu_cmd_t *cmd; | |
| struct vpu_cmd_t *tmp; | |
| if (!inst || inst->pending) | |
| return; | |
| list_for_each_entry_safe(cmd, tmp, &inst->cmd_q, list) { | |
| list_del_init(&cmd->list); | |
| if (vpu_session_process_cmd(inst, cmd)) | |
| dev_err(inst->dev, "[%d] process cmd %s fail\n", | |
| inst->id, vpu_id_name(cmd->id)); | |
| if (cmd->request) { | |
| inst->pending = (void *)cmd; | |
| break; | |
| } | |
| vpu_free_cmd(cmd); | |
| } | |
| } | |
| static int vpu_request_cmd(struct vpu_inst *inst, u32 id, void *data, | |
| unsigned long *key, int *sync) | |
| { | |
| struct vpu_core *core; | |
| struct vpu_cmd_t *cmd; | |
| if (!inst || !inst->core) | |
| return -EINVAL; | |
| core = inst->core; | |
| cmd = vpu_alloc_cmd(inst, id, data); | |
| if (!cmd) | |
| return -ENOMEM; | |
| mutex_lock(&core->cmd_lock); | |
| cmd->key = ++inst->cmd_seq; | |
| cmd->last_response_cmd = &inst->last_response_cmd; | |
| if (key) | |
| *key = cmd->key; | |
| if (sync) | |
| *sync = cmd->request ? true : false; | |
| list_add_tail(&cmd->list, &inst->cmd_q); | |
| vpu_process_cmd_request(inst); | |
| mutex_unlock(&core->cmd_lock); | |
| return 0; | |
| } | |
| static void vpu_clear_pending(struct vpu_inst *inst) | |
| { | |
| if (!inst || !inst->pending) | |
| return; | |
| vpu_free_cmd(inst->pending); | |
| wake_up_all(&inst->core->ack_wq); | |
| inst->pending = NULL; | |
| } | |
| static bool vpu_check_response(struct vpu_cmd_t *cmd, u32 response, u32 handled) | |
| { | |
| struct vpu_cmd_request *request; | |
| if (!cmd || !cmd->request) | |
| return false; | |
| request = cmd->request; | |
| if (request->response != response) | |
| return false; | |
| if (request->handled != handled) | |
| return false; | |
| return true; | |
| } | |
| int vpu_response_cmd(struct vpu_inst *inst, u32 response, u32 handled) | |
| { | |
| struct vpu_core *core; | |
| if (!inst || !inst->core) | |
| return -EINVAL; | |
| core = inst->core; | |
| mutex_lock(&core->cmd_lock); | |
| if (vpu_check_response(inst->pending, response, handled)) | |
| vpu_clear_pending(inst); | |
| vpu_process_cmd_request(inst); | |
| mutex_unlock(&core->cmd_lock); | |
| return 0; | |
| } | |
| void vpu_clear_request(struct vpu_inst *inst) | |
| { | |
| struct vpu_cmd_t *cmd; | |
| struct vpu_cmd_t *tmp; | |
| mutex_lock(&inst->core->cmd_lock); | |
| if (inst->pending) | |
| vpu_clear_pending(inst); | |
| list_for_each_entry_safe(cmd, tmp, &inst->cmd_q, list) { | |
| list_del_init(&cmd->list); | |
| vpu_free_cmd(cmd); | |
| } | |
| mutex_unlock(&inst->core->cmd_lock); | |
| } | |
| static bool check_is_responsed(struct vpu_inst *inst, unsigned long key) | |
| { | |
| unsigned long last_response = atomic_long_read(&inst->last_response_cmd); | |
| if (key <= last_response && (last_response - key) < (ULONG_MAX >> 1)) | |
| return true; | |
| return false; | |
| } | |
| static int sync_session_response(struct vpu_inst *inst, unsigned long key, long timeout, int try) | |
| { | |
| struct vpu_core *core; | |
| if (!inst || !inst->core) | |
| return -EINVAL; | |
| core = inst->core; | |
| call_void_vop(inst, wait_prepare); | |
| wait_event_timeout(core->ack_wq, check_is_responsed(inst, key), timeout); | |
| call_void_vop(inst, wait_finish); | |
| if (!check_is_responsed(inst, key)) { | |
| if (try) | |
| return -EINVAL; | |
| dev_err(inst->dev, "[%d] sync session timeout\n", inst->id); | |
| set_bit(inst->id, &core->hang_mask); | |
| mutex_lock(&inst->core->cmd_lock); | |
| vpu_clear_pending(inst); | |
| mutex_unlock(&inst->core->cmd_lock); | |
| return -EINVAL; | |
| } | |
| return 0; | |
| } | |
| static void vpu_core_keep_active(struct vpu_core *core) | |
| { | |
| struct vpu_rpc_event pkt; | |
| memset(&pkt, 0, sizeof(pkt)); | |
| vpu_iface_pack_cmd(core, &pkt, 0, VPU_CMD_ID_NOOP, NULL); | |
| dev_dbg(core->dev, "try to wake up\n"); | |
| mutex_lock(&core->cmd_lock); | |
| if (vpu_cmd_send(core, &pkt)) | |
| dev_err(core->dev, "fail to keep active\n"); | |
| mutex_unlock(&core->cmd_lock); | |
| } | |
| static int vpu_session_send_cmd(struct vpu_inst *inst, u32 id, void *data) | |
| { | |
| unsigned long key; | |
| int sync = false; | |
| int ret; | |
| if (inst->id < 0) | |
| return -EINVAL; | |
| ret = vpu_request_cmd(inst, id, data, &key, &sync); | |
| if (ret) | |
| goto exit; | |
| /* workaround for a firmware issue, | |
| * firmware should be waked up by start or configure command, | |
| * but there is a very small change that firmware failed to wakeup. | |
| * in such case, try to wakeup firmware again by sending a noop command | |
| */ | |
| if (sync && (id == VPU_CMD_ID_CONFIGURE_CODEC || id == VPU_CMD_ID_START)) { | |
| if (sync_session_response(inst, key, VPU_TIMEOUT_WAKEUP, 1)) | |
| vpu_core_keep_active(inst->core); | |
| else | |
| goto exit; | |
| } | |
| if (sync) | |
| ret = sync_session_response(inst, key, VPU_TIMEOUT, 0); | |
| exit: | |
| if (ret) | |
| dev_err(inst->dev, "[%d] send cmd %s fail\n", inst->id, vpu_id_name(id)); | |
| return ret; | |
| } | |
| int vpu_session_configure_codec(struct vpu_inst *inst) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_CONFIGURE_CODEC, NULL); | |
| } | |
| int vpu_session_start(struct vpu_inst *inst) | |
| { | |
| vpu_trace(inst->dev, "[%d]\n", inst->id); | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_START, NULL); | |
| } | |
| int vpu_session_stop(struct vpu_inst *inst) | |
| { | |
| int ret; | |
| vpu_trace(inst->dev, "[%d]\n", inst->id); | |
| ret = vpu_session_send_cmd(inst, VPU_CMD_ID_STOP, NULL); | |
| /* workaround for a firmware bug, | |
| * if the next command is too close after stop cmd, | |
| * the firmware may enter wfi wrongly. | |
| */ | |
| usleep_range(3000, 5000); | |
| return ret; | |
| } | |
| int vpu_session_encode_frame(struct vpu_inst *inst, s64 timestamp) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_FRAME_ENCODE, ×tamp); | |
| } | |
| int vpu_session_alloc_fs(struct vpu_inst *inst, struct vpu_fs_info *fs) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_FS_ALLOC, fs); | |
| } | |
| int vpu_session_release_fs(struct vpu_inst *inst, struct vpu_fs_info *fs) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_FS_RELEASE, fs); | |
| } | |
| int vpu_session_abort(struct vpu_inst *inst) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_ABORT, NULL); | |
| } | |
| int vpu_session_rst_buf(struct vpu_inst *inst) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_RST_BUF, NULL); | |
| } | |
| int vpu_session_fill_timestamp(struct vpu_inst *inst, struct vpu_ts_info *info) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_TIMESTAMP, info); | |
| } | |
| int vpu_session_update_parameters(struct vpu_inst *inst, void *arg) | |
| { | |
| if (inst->type & VPU_CORE_TYPE_DEC) | |
| vpu_iface_set_decode_params(inst, arg, 1); | |
| else | |
| vpu_iface_set_encode_params(inst, arg, 1); | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_UPDATE_PARAMETER, arg); | |
| } | |
| int vpu_session_debug(struct vpu_inst *inst) | |
| { | |
| return vpu_session_send_cmd(inst, VPU_CMD_ID_DEBUG, NULL); | |
| } | |
| int vpu_core_snapshot(struct vpu_core *core) | |
| { | |
| struct vpu_inst *inst; | |
| int ret; | |
| if (!core || list_empty(&core->instances)) | |
| return 0; | |
| inst = list_first_entry(&core->instances, struct vpu_inst, list); | |
| reinit_completion(&core->cmp); | |
| ret = vpu_session_send_cmd(inst, VPU_CMD_ID_SNAPSHOT, NULL); | |
| if (ret) | |
| return ret; | |
| ret = wait_for_completion_timeout(&core->cmp, VPU_TIMEOUT); | |
| if (!ret) { | |
| dev_err(core->dev, "snapshot timeout\n"); | |
| return -EINVAL; | |
| } | |
| return 0; | |
| } | |
| int vpu_core_sw_reset(struct vpu_core *core) | |
| { | |
| struct vpu_rpc_event pkt; | |
| int ret; | |
| memset(&pkt, 0, sizeof(pkt)); | |
| vpu_iface_pack_cmd(core, &pkt, 0, VPU_CMD_ID_FIRM_RESET, NULL); | |
| reinit_completion(&core->cmp); | |
| mutex_lock(&core->cmd_lock); | |
| ret = vpu_cmd_send(core, &pkt); | |
| mutex_unlock(&core->cmd_lock); | |
| if (ret) | |
| return ret; | |
| ret = wait_for_completion_timeout(&core->cmp, VPU_TIMEOUT); | |
| if (!ret) { | |
| dev_err(core->dev, "sw reset timeout\n"); | |
| return -EINVAL; | |
| } | |
| return 0; | |
| } |