1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright 2020-2021 NXP 4 */ 5 6 #include <linux/init.h> 7 #include <linux/interconnect.h> 8 #include <linux/ioctl.h> 9 #include <linux/list.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/of_device.h> 13 #include <linux/of_address.h> 14 #include <linux/platform_device.h> 15 #include <linux/slab.h> 16 #include <linux/types.h> 17 #include <linux/delay.h> 18 #include <linux/vmalloc.h> 19 #include "vpu.h" 20 #include "vpu_defs.h" 21 #include "vpu_cmds.h" 22 #include "vpu_rpc.h" 23 #include "vpu_mbox.h" 24 25 struct vpu_cmd_request { 26 u32 request; 27 u32 response; 28 u32 handled; 29 }; 30 31 struct vpu_cmd_t { 32 struct list_head list; 33 u32 id; 34 struct vpu_cmd_request *request; 35 struct vpu_rpc_event *pkt; 36 unsigned long key; 37 }; 38 39 static struct vpu_cmd_request vpu_cmd_requests[] = { 40 { 41 .request = VPU_CMD_ID_CONFIGURE_CODEC, 42 .response = VPU_MSG_ID_MEM_REQUEST, 43 .handled = 1, 44 }, 45 { 46 .request = VPU_CMD_ID_START, 47 .response = VPU_MSG_ID_START_DONE, 48 .handled = 0, 49 }, 50 { 51 .request = VPU_CMD_ID_STOP, 52 .response = VPU_MSG_ID_STOP_DONE, 53 .handled = 0, 54 }, 55 { 56 .request = VPU_CMD_ID_ABORT, 57 .response = VPU_MSG_ID_ABORT_DONE, 58 .handled = 0, 59 }, 60 { 61 .request = VPU_CMD_ID_RST_BUF, 62 .response = VPU_MSG_ID_BUF_RST, 63 .handled = 1, 64 }, 65 }; 66 67 static int vpu_cmd_send(struct vpu_core *core, struct vpu_rpc_event *pkt) 68 { 69 int ret = 0; 70 71 ret = vpu_iface_send_cmd(core, pkt); 72 if (ret) 73 return ret; 74 75 /*write cmd data to cmd buffer before trigger a cmd interrupt*/ 76 mb(); 77 vpu_mbox_send_type(core, COMMAND); 78 79 return ret; 80 } 81 82 static struct vpu_cmd_t *vpu_alloc_cmd(struct vpu_inst *inst, u32 id, void *data) 83 { 84 struct vpu_cmd_t *cmd; 85 int i; 86 int ret; 87 88 cmd = vzalloc(sizeof(*cmd)); 89 if (!cmd) 90 return NULL; 91 92 cmd->pkt = vzalloc(sizeof(*cmd->pkt)); 93 if (!cmd->pkt) { 94 vfree(cmd); 95 return NULL; 96 } 97 98 cmd->id = id; 99 ret = vpu_iface_pack_cmd(inst->core, cmd->pkt, inst->id, id, data); 100 if (ret) { 101 dev_err(inst->dev, "iface pack cmd(%d) fail\n", id); 102 vfree(cmd->pkt); 103 vfree(cmd); 104 return NULL; 105 } 106 for (i = 0; i < ARRAY_SIZE(vpu_cmd_requests); i++) { 107 if (vpu_cmd_requests[i].request == id) { 108 cmd->request = &vpu_cmd_requests[i]; 109 break; 110 } 111 } 112 113 return cmd; 114 } 115 116 static void vpu_free_cmd(struct vpu_cmd_t *cmd) 117 { 118 if (!cmd) 119 return; 120 if (cmd->pkt) 121 vfree(cmd->pkt); 122 vfree(cmd); 123 } 124 125 static int vpu_session_process_cmd(struct vpu_inst *inst, struct vpu_cmd_t *cmd) 126 { 127 int ret; 128 129 dev_dbg(inst->dev, "[%d]send cmd(0x%x)\n", inst->id, cmd->id); 130 vpu_iface_pre_send_cmd(inst); 131 ret = vpu_cmd_send(inst->core, cmd->pkt); 132 if (!ret) { 133 vpu_iface_post_send_cmd(inst); 134 vpu_inst_record_flow(inst, cmd->id); 135 } else { 136 dev_err(inst->dev, "[%d] iface send cmd(0x%x) fail\n", inst->id, cmd->id); 137 } 138 139 return ret; 140 } 141 142 static void vpu_process_cmd_request(struct vpu_inst *inst) 143 { 144 struct vpu_cmd_t *cmd; 145 struct vpu_cmd_t *tmp; 146 147 if (!inst || inst->pending) 148 return; 149 150 list_for_each_entry_safe(cmd, tmp, &inst->cmd_q, list) { 151 list_del_init(&cmd->list); 152 if (vpu_session_process_cmd(inst, cmd)) 153 dev_err(inst->dev, "[%d] process cmd(%d) fail\n", inst->id, cmd->id); 154 if (cmd->request) { 155 inst->pending = (void *)cmd; 156 break; 157 } 158 vpu_free_cmd(cmd); 159 } 160 } 161 162 static int vpu_request_cmd(struct vpu_inst *inst, u32 id, void *data, 163 unsigned long *key, int *sync) 164 { 165 struct vpu_core *core; 166 struct vpu_cmd_t *cmd; 167 168 if (!inst || !inst->core) 169 return -EINVAL; 170 171 core = inst->core; 172 cmd = vpu_alloc_cmd(inst, id, data); 173 if (!cmd) 174 return -ENOMEM; 175 176 mutex_lock(&core->cmd_lock); 177 cmd->key = core->cmd_seq++; 178 if (key) 179 *key = cmd->key; 180 if (sync) 181 *sync = cmd->request ? true : false; 182 list_add_tail(&cmd->list, &inst->cmd_q); 183 vpu_process_cmd_request(inst); 184 mutex_unlock(&core->cmd_lock); 185 186 return 0; 187 } 188 189 static void vpu_clear_pending(struct vpu_inst *inst) 190 { 191 if (!inst || !inst->pending) 192 return; 193 194 vpu_free_cmd(inst->pending); 195 wake_up_all(&inst->core->ack_wq); 196 inst->pending = NULL; 197 } 198 199 static bool vpu_check_response(struct vpu_cmd_t *cmd, u32 response, u32 handled) 200 { 201 struct vpu_cmd_request *request; 202 203 if (!cmd || !cmd->request) 204 return false; 205 206 request = cmd->request; 207 if (request->response != response) 208 return false; 209 if (request->handled != handled) 210 return false; 211 212 return true; 213 } 214 215 int vpu_response_cmd(struct vpu_inst *inst, u32 response, u32 handled) 216 { 217 struct vpu_core *core; 218 219 if (!inst || !inst->core) 220 return -EINVAL; 221 222 core = inst->core; 223 mutex_lock(&core->cmd_lock); 224 if (vpu_check_response(inst->pending, response, handled)) 225 vpu_clear_pending(inst); 226 227 vpu_process_cmd_request(inst); 228 mutex_unlock(&core->cmd_lock); 229 230 return 0; 231 } 232 233 void vpu_clear_request(struct vpu_inst *inst) 234 { 235 struct vpu_cmd_t *cmd; 236 struct vpu_cmd_t *tmp; 237 238 mutex_lock(&inst->core->cmd_lock); 239 if (inst->pending) 240 vpu_clear_pending(inst); 241 242 list_for_each_entry_safe(cmd, tmp, &inst->cmd_q, list) { 243 list_del_init(&cmd->list); 244 vpu_free_cmd(cmd); 245 } 246 mutex_unlock(&inst->core->cmd_lock); 247 } 248 249 static bool check_is_responsed(struct vpu_inst *inst, unsigned long key) 250 { 251 struct vpu_core *core = inst->core; 252 struct vpu_cmd_t *cmd; 253 bool flag = true; 254 255 mutex_lock(&core->cmd_lock); 256 cmd = inst->pending; 257 if (cmd && key == cmd->key) { 258 flag = false; 259 goto exit; 260 } 261 list_for_each_entry(cmd, &inst->cmd_q, list) { 262 if (key == cmd->key) { 263 flag = false; 264 break; 265 } 266 } 267 exit: 268 mutex_unlock(&core->cmd_lock); 269 270 return flag; 271 } 272 273 static int sync_session_response(struct vpu_inst *inst, unsigned long key) 274 { 275 struct vpu_core *core; 276 277 if (!inst || !inst->core) 278 return -EINVAL; 279 280 core = inst->core; 281 282 call_void_vop(inst, wait_prepare); 283 wait_event_timeout(core->ack_wq, check_is_responsed(inst, key), VPU_TIMEOUT); 284 call_void_vop(inst, wait_finish); 285 286 if (!check_is_responsed(inst, key)) { 287 dev_err(inst->dev, "[%d] sync session timeout\n", inst->id); 288 set_bit(inst->id, &core->hang_mask); 289 mutex_lock(&inst->core->cmd_lock); 290 vpu_clear_pending(inst); 291 mutex_unlock(&inst->core->cmd_lock); 292 return -EINVAL; 293 } 294 295 return 0; 296 } 297 298 static int vpu_session_send_cmd(struct vpu_inst *inst, u32 id, void *data) 299 { 300 unsigned long key; 301 int sync = false; 302 int ret = -EINVAL; 303 304 if (inst->id < 0) 305 return -EINVAL; 306 307 ret = vpu_request_cmd(inst, id, data, &key, &sync); 308 if (!ret && sync) 309 ret = sync_session_response(inst, key); 310 311 if (ret) 312 dev_err(inst->dev, "[%d] send cmd(0x%x) fail\n", inst->id, id); 313 314 return ret; 315 } 316 317 int vpu_session_configure_codec(struct vpu_inst *inst) 318 { 319 return vpu_session_send_cmd(inst, VPU_CMD_ID_CONFIGURE_CODEC, NULL); 320 } 321 322 int vpu_session_start(struct vpu_inst *inst) 323 { 324 vpu_trace(inst->dev, "[%d]\n", inst->id); 325 326 return vpu_session_send_cmd(inst, VPU_CMD_ID_START, NULL); 327 } 328 329 int vpu_session_stop(struct vpu_inst *inst) 330 { 331 int ret; 332 333 vpu_trace(inst->dev, "[%d]\n", inst->id); 334 335 ret = vpu_session_send_cmd(inst, VPU_CMD_ID_STOP, NULL); 336 /* workaround for a firmware bug, 337 * if the next command is too close after stop cmd, 338 * the firmware may enter wfi wrongly. 339 */ 340 usleep_range(3000, 5000); 341 return ret; 342 } 343 344 int vpu_session_encode_frame(struct vpu_inst *inst, s64 timestamp) 345 { 346 return vpu_session_send_cmd(inst, VPU_CMD_ID_FRAME_ENCODE, ×tamp); 347 } 348 349 int vpu_session_alloc_fs(struct vpu_inst *inst, struct vpu_fs_info *fs) 350 { 351 return vpu_session_send_cmd(inst, VPU_CMD_ID_FS_ALLOC, fs); 352 } 353 354 int vpu_session_release_fs(struct vpu_inst *inst, struct vpu_fs_info *fs) 355 { 356 return vpu_session_send_cmd(inst, VPU_CMD_ID_FS_RELEASE, fs); 357 } 358 359 int vpu_session_abort(struct vpu_inst *inst) 360 { 361 return vpu_session_send_cmd(inst, VPU_CMD_ID_ABORT, NULL); 362 } 363 364 int vpu_session_rst_buf(struct vpu_inst *inst) 365 { 366 return vpu_session_send_cmd(inst, VPU_CMD_ID_RST_BUF, NULL); 367 } 368 369 int vpu_session_fill_timestamp(struct vpu_inst *inst, struct vpu_ts_info *info) 370 { 371 return vpu_session_send_cmd(inst, VPU_CMD_ID_TIMESTAMP, info); 372 } 373 374 int vpu_session_update_parameters(struct vpu_inst *inst, void *arg) 375 { 376 if (inst->type & VPU_CORE_TYPE_DEC) 377 vpu_iface_set_decode_params(inst, arg, 1); 378 else 379 vpu_iface_set_encode_params(inst, arg, 1); 380 381 return vpu_session_send_cmd(inst, VPU_CMD_ID_UPDATE_PARAMETER, arg); 382 } 383 384 int vpu_session_debug(struct vpu_inst *inst) 385 { 386 return vpu_session_send_cmd(inst, VPU_CMD_ID_DEBUG, NULL); 387 } 388 389 int vpu_core_snapshot(struct vpu_core *core) 390 { 391 struct vpu_inst *inst; 392 int ret; 393 394 if (!core || list_empty(&core->instances)) 395 return 0; 396 397 inst = list_first_entry(&core->instances, struct vpu_inst, list); 398 399 reinit_completion(&core->cmp); 400 ret = vpu_session_send_cmd(inst, VPU_CMD_ID_SNAPSHOT, NULL); 401 if (ret) 402 return ret; 403 ret = wait_for_completion_timeout(&core->cmp, VPU_TIMEOUT); 404 if (!ret) { 405 dev_err(core->dev, "snapshot timeout\n"); 406 return -EINVAL; 407 } 408 409 return 0; 410 } 411 412 int vpu_core_sw_reset(struct vpu_core *core) 413 { 414 struct vpu_rpc_event pkt; 415 int ret; 416 417 memset(&pkt, 0, sizeof(pkt)); 418 vpu_iface_pack_cmd(core, &pkt, 0, VPU_CMD_ID_FIRM_RESET, NULL); 419 420 reinit_completion(&core->cmp); 421 mutex_lock(&core->cmd_lock); 422 ret = vpu_cmd_send(core, &pkt); 423 mutex_unlock(&core->cmd_lock); 424 if (ret) 425 return ret; 426 ret = wait_for_completion_timeout(&core->cmp, VPU_TIMEOUT); 427 if (!ret) { 428 dev_err(core->dev, "sw reset timeout\n"); 429 return -EINVAL; 430 } 431 432 return 0; 433 } 434