Lines Matching refs:hdev
138 static void venus_set_state(struct venus_hfi_device *hdev,
141 mutex_lock(&hdev->lock);
142 hdev->state = state;
143 mutex_unlock(&hdev->lock);
146 static bool venus_is_valid_state(struct venus_hfi_device *hdev)
148 return hdev->state != VENUS_STATE_DEINIT;
151 static void venus_dump_packet(struct venus_hfi_device *hdev, const void *packet)
162 static int venus_write_queue(struct venus_hfi_device *hdev,
178 venus_dump_packet(hdev, packet);
239 static int venus_read_queue(struct venus_hfi_device *hdev,
339 venus_dump_packet(hdev, pkt);
344 static int venus_alloc(struct venus_hfi_device *hdev, struct mem_desc *desc,
347 struct device *dev = hdev->core->dev;
360 static void venus_free(struct venus_hfi_device *hdev, struct mem_desc *mem)
362 struct device *dev = hdev->core->dev;
367 static void venus_set_registers(struct venus_hfi_device *hdev)
369 const struct venus_resources *res = hdev->core->res;
375 writel(tbl[i].value, hdev->core->base + tbl[i].reg);
378 static void venus_soft_int(struct venus_hfi_device *hdev)
380 void __iomem *cpu_ic_base = hdev->core->cpu_ic_base;
383 if (IS_V6(hdev->core))
391 static int venus_iface_cmdq_write_nolock(struct venus_hfi_device *hdev,
394 struct device *dev = hdev->core->dev;
400 if (!venus_is_valid_state(hdev))
404 hdev->last_packet_type = cmd_packet->pkt_type;
406 queue = &hdev->queues[IFACEQ_CMD_IDX];
408 ret = venus_write_queue(hdev, queue, pkt, &rx_req);
419 queue = &hdev->queues[IFACEQ_MSG_IDX];
426 venus_soft_int(hdev);
431 static int venus_iface_cmdq_write(struct venus_hfi_device *hdev, void *pkt, bool sync)
435 mutex_lock(&hdev->lock);
436 ret = venus_iface_cmdq_write_nolock(hdev, pkt, sync);
437 mutex_unlock(&hdev->lock);
445 struct venus_hfi_device *hdev = to_hfi_priv(core);
459 ret = venus_iface_cmdq_write(hdev, pkt, false);
466 static int venus_boot_core(struct venus_hfi_device *hdev)
468 struct device *dev = hdev->core->dev;
472 void __iomem *cpu_cs_base = hdev->core->cpu_cs_base;
473 void __iomem *wrapper_base = hdev->core->wrapper_base;
476 if (IS_IRIS2(hdev->core) || IS_IRIS2_1(hdev->core)) {
485 if (IS_V1(hdev->core))
504 if (IS_IRIS2(hdev->core) || IS_IRIS2_1(hdev->core)) {
512 static u32 venus_hwversion(struct venus_hfi_device *hdev)
514 struct device *dev = hdev->core->dev;
515 void __iomem *wrapper_base = hdev->core->wrapper_base;
531 static int venus_run(struct venus_hfi_device *hdev)
533 struct device *dev = hdev->core->dev;
534 void __iomem *cpu_cs_base = hdev->core->cpu_cs_base;
541 venus_set_registers(hdev);
543 writel(hdev->ifaceq_table.da, cpu_cs_base + UC_REGION_ADDR);
545 writel(hdev->ifaceq_table.da, cpu_cs_base + CPU_CS_SCIACMDARG2);
547 if (hdev->sfr.da)
548 writel(hdev->sfr.da, cpu_cs_base + SFR_ADDR);
550 ret = venus_boot_core(hdev);
556 venus_hwversion(hdev);
561 static int venus_halt_axi(struct venus_hfi_device *hdev)
563 void __iomem *wrapper_base = hdev->core->wrapper_base;
564 void __iomem *vbif_base = hdev->core->vbif_base;
565 void __iomem *cpu_cs_base = hdev->core->cpu_cs_base;
566 void __iomem *aon_base = hdev->core->aon_base;
567 struct device *dev = hdev->core->dev;
572 if (IS_IRIS2(hdev->core) || IS_IRIS2_1(hdev->core)) {
575 if (IS_IRIS2_1(hdev->core))
605 if (IS_V4(hdev->core)) {
641 static int venus_power_off(struct venus_hfi_device *hdev)
645 if (!hdev->power_enabled)
648 ret = venus_set_hw_state_suspend(hdev->core);
652 ret = venus_halt_axi(hdev);
656 hdev->power_enabled = false;
661 static int venus_power_on(struct venus_hfi_device *hdev)
665 if (hdev->power_enabled)
668 ret = venus_set_hw_state_resume(hdev->core);
672 ret = venus_run(hdev);
676 hdev->power_enabled = true;
681 venus_set_hw_state_suspend(hdev->core);
683 hdev->power_enabled = false;
687 static int venus_iface_msgq_read_nolock(struct venus_hfi_device *hdev,
694 if (!venus_is_valid_state(hdev))
697 queue = &hdev->queues[IFACEQ_MSG_IDX];
699 ret = venus_read_queue(hdev, queue, pkt, &tx_req);
704 venus_soft_int(hdev);
709 static int venus_iface_msgq_read(struct venus_hfi_device *hdev, void *pkt)
713 mutex_lock(&hdev->lock);
714 ret = venus_iface_msgq_read_nolock(hdev, pkt);
715 mutex_unlock(&hdev->lock);
720 static int venus_iface_dbgq_read_nolock(struct venus_hfi_device *hdev,
727 ret = venus_is_valid_state(hdev);
731 queue = &hdev->queues[IFACEQ_DBG_IDX];
733 ret = venus_read_queue(hdev, queue, pkt, &tx_req);
738 venus_soft_int(hdev);
743 static int venus_iface_dbgq_read(struct venus_hfi_device *hdev, void *pkt)
750 mutex_lock(&hdev->lock);
751 ret = venus_iface_dbgq_read_nolock(hdev, pkt);
752 mutex_unlock(&hdev->lock);
773 static void venus_interface_queues_release(struct venus_hfi_device *hdev)
775 mutex_lock(&hdev->lock);
777 venus_free(hdev, &hdev->ifaceq_table);
778 venus_free(hdev, &hdev->sfr);
780 memset(hdev->queues, 0, sizeof(hdev->queues));
781 memset(&hdev->ifaceq_table, 0, sizeof(hdev->ifaceq_table));
782 memset(&hdev->sfr, 0, sizeof(hdev->sfr));
784 mutex_unlock(&hdev->lock);
787 static int venus_interface_queues_init(struct venus_hfi_device *hdev)
797 ret = venus_alloc(hdev, &desc, ALIGNED_QUEUE_SIZE);
801 hdev->ifaceq_table = desc;
805 queue = &hdev->queues[i];
811 IFACEQ_GET_QHDR_START_ADDR(hdev->ifaceq_table.kva, i);
825 tbl_hdr = hdev->ifaceq_table.kva;
837 queue = &hdev->queues[IFACEQ_DBG_IDX];
840 ret = venus_alloc(hdev, &desc, ALIGNED_SFR_SIZE);
842 hdev->sfr.da = 0;
844 hdev->sfr = desc;
845 sfr = hdev->sfr.kva;
855 static int venus_sys_set_debug(struct venus_hfi_device *hdev, u32 debug)
864 return venus_iface_cmdq_write(hdev, pkt, false);
867 static int venus_sys_set_coverage(struct venus_hfi_device *hdev, u32 mode)
876 return venus_iface_cmdq_write(hdev, pkt, false);
879 static int venus_sys_set_idle_message(struct venus_hfi_device *hdev,
892 return venus_iface_cmdq_write(hdev, pkt, false);
895 static int venus_sys_set_power_control(struct venus_hfi_device *hdev,
905 return venus_iface_cmdq_write(hdev, pkt, false);
908 static int venus_sys_set_ubwc_config(struct venus_hfi_device *hdev)
912 const struct venus_resources *res = hdev->core->res;
919 ret = venus_iface_cmdq_write(hdev, pkt, false);
926 static int venus_get_queue_size(struct venus_hfi_device *hdev,
934 qhdr = hdev->queues[index].qhdr;
941 static int venus_sys_set_default_properties(struct venus_hfi_device *hdev)
943 struct device *dev = hdev->core->dev;
944 const struct venus_resources *res = hdev->core->res;
947 ret = venus_sys_set_debug(hdev, venus_fw_debug);
952 if (IS_V1(hdev->core)) {
953 ret = venus_sys_set_idle_message(hdev, false);
958 ret = venus_sys_set_power_control(hdev, venus_fw_low_power_mode);
965 ret = venus_sys_set_ubwc_config(hdev);
975 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
980 return venus_iface_cmdq_write(hdev, &pkt, sync);
983 static void venus_flush_debug_queue(struct venus_hfi_device *hdev)
985 struct device *dev = hdev->core->dev;
986 void *packet = hdev->dbg_buf;
988 while (!venus_iface_dbgq_read(hdev, packet)) {
999 static int venus_prepare_power_collapse(struct venus_hfi_device *hdev,
1006 init_completion(&hdev->pwr_collapse_prep);
1010 ret = venus_iface_cmdq_write(hdev, &pkt, false);
1017 ret = wait_for_completion_timeout(&hdev->pwr_collapse_prep, timeout);
1019 venus_flush_debug_queue(hdev);
1026 static int venus_are_queues_empty(struct venus_hfi_device *hdev)
1030 ret1 = venus_get_queue_size(hdev, IFACEQ_MSG_IDX);
1034 ret2 = venus_get_queue_size(hdev, IFACEQ_CMD_IDX);
1044 static void venus_sfr_print(struct venus_hfi_device *hdev)
1046 struct device *dev = hdev->core->dev;
1047 struct hfi_sfr *sfr = hdev->sfr.kva;
1072 static void venus_process_msg_sys_error(struct venus_hfi_device *hdev,
1080 venus_set_state(hdev, VENUS_STATE_DEINIT);
1082 venus_sfr_print(hdev);
1087 struct venus_hfi_device *hdev = to_hfi_priv(core);
1092 if (!hdev)
1095 res = hdev->core->res;
1096 pkt = hdev->pkt_buf;
1099 while (!venus_iface_msgq_read(hdev, pkt)) {
1103 venus_process_msg_sys_error(hdev, pkt);
1109 hdev);
1112 complete(&hdev->release_resource);
1115 complete(&hdev->pwr_collapse_prep);
1122 venus_flush_debug_queue(hdev);
1129 struct venus_hfi_device *hdev = to_hfi_priv(core);
1134 if (!hdev)
1137 cpu_cs_base = hdev->core->cpu_cs_base;
1138 wrapper_base = hdev->core->wrapper_base;
1145 hdev->irq_status = status;
1150 hdev->irq_status = status;
1161 struct venus_hfi_device *hdev = to_hfi_priv(core);
1169 venus_set_state(hdev, VENUS_STATE_INIT);
1171 ret = venus_iface_cmdq_write(hdev, &pkt, false);
1177 ret = venus_iface_cmdq_write(hdev, &version_pkt, false);
1181 ret = venus_sys_set_default_properties(hdev);
1190 struct venus_hfi_device *hdev = to_hfi_priv(core);
1192 venus_set_state(hdev, VENUS_STATE_DEINIT);
1193 hdev->suspended = true;
1194 hdev->power_enabled = false;
1201 struct venus_hfi_device *hdev = to_hfi_priv(core);
1209 return venus_iface_cmdq_write(hdev, &pkt, false);
1215 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1219 ret = venus_sys_set_debug(hdev, venus_fw_debug);
1227 ret = venus_iface_cmdq_write(hdev, &pkt, true);
1234 venus_flush_debug_queue(hdev);
1240 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1241 struct device *dev = hdev->core->dev;
1244 if (venus_sys_set_coverage(hdev, venus_fw_coverage))
1253 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1255 venus_flush_debug_queue(hdev);
1262 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1270 return venus_iface_cmdq_write(hdev, &pkt, true);
1291 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1302 ret = venus_iface_cmdq_write(hdev, &pkt, false);
1310 ret = venus_iface_cmdq_write(hdev, &pkt, false);
1321 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1329 return venus_iface_cmdq_write(hdev, &pkt, false);
1335 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1349 return venus_iface_cmdq_write(hdev, pkt, false);
1355 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1369 return venus_iface_cmdq_write(hdev, pkt, true);
1385 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1396 ret = venus_iface_cmdq_write(hdev, pkt, false);
1406 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1417 return venus_iface_cmdq_write(hdev, pkt, false);
1423 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1436 return venus_iface_cmdq_write(hdev, pkt, false);
1441 struct venus_hfi_device *hdev = to_hfi_priv(inst->core);
1449 return venus_iface_cmdq_write(hdev, &pkt, true);
1454 struct venus_hfi_device *hdev = to_hfi_priv(core);
1457 mutex_lock(&hdev->lock);
1459 if (!hdev->suspended)
1462 ret = venus_power_on(hdev);
1466 hdev->suspended = false;
1468 mutex_unlock(&hdev->lock);
1475 struct venus_hfi_device *hdev = to_hfi_priv(core);
1477 void __iomem *cpu_cs_base = hdev->core->cpu_cs_base;
1481 if (!hdev->power_enabled || hdev->suspended)
1484 mutex_lock(&hdev->lock);
1485 ret = venus_is_valid_state(hdev);
1486 mutex_unlock(&hdev->lock);
1493 ret = venus_prepare_power_collapse(hdev, true);
1499 mutex_lock(&hdev->lock);
1501 if (hdev->last_packet_type != HFI_CMD_SYS_PC_PREP) {
1502 mutex_unlock(&hdev->lock);
1506 ret = venus_are_queues_empty(hdev);
1508 mutex_unlock(&hdev->lock);
1514 mutex_unlock(&hdev->lock);
1518 ret = venus_power_off(hdev);
1520 mutex_unlock(&hdev->lock);
1524 hdev->suspended = true;
1526 mutex_unlock(&hdev->lock);
1531 static bool venus_cpu_and_video_core_idle(struct venus_hfi_device *hdev)
1533 void __iomem *wrapper_base = hdev->core->wrapper_base;
1534 void __iomem *wrapper_tz_base = hdev->core->wrapper_tz_base;
1535 void __iomem *cpu_cs_base = hdev->core->cpu_cs_base;
1538 if (IS_IRIS2(hdev->core) || IS_IRIS2_1(hdev->core))
1551 static bool venus_cpu_idle_and_pc_ready(struct venus_hfi_device *hdev)
1553 void __iomem *wrapper_base = hdev->core->wrapper_base;
1554 void __iomem *wrapper_tz_base = hdev->core->wrapper_tz_base;
1555 void __iomem *cpu_cs_base = hdev->core->cpu_cs_base;
1558 if (IS_IRIS2(hdev->core) || IS_IRIS2_1(hdev->core))
1573 struct venus_hfi_device *hdev = to_hfi_priv(core);
1575 void __iomem *cpu_cs_base = hdev->core->cpu_cs_base;
1580 if (!hdev->power_enabled || hdev->suspended)
1583 mutex_lock(&hdev->lock);
1584 ret = venus_is_valid_state(hdev);
1585 mutex_unlock(&hdev->lock);
1604 ret = readx_poll_timeout(venus_cpu_and_video_core_idle, hdev, val, val,
1611 ret = venus_prepare_power_collapse(hdev, false);
1617 ret = readx_poll_timeout(venus_cpu_idle_and_pc_ready, hdev, val, val,
1623 mutex_lock(&hdev->lock);
1625 ret = venus_power_off(hdev);
1628 mutex_unlock(&hdev->lock);
1632 hdev->suspended = true;
1634 mutex_unlock(&hdev->lock);
1679 struct venus_hfi_device *hdev = to_hfi_priv(core);
1682 venus_interface_queues_release(hdev);
1683 mutex_destroy(&hdev->lock);
1684 kfree(hdev);
1691 struct venus_hfi_device *hdev;
1694 hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
1695 if (!hdev)
1698 mutex_init(&hdev->lock);
1700 hdev->core = core;
1701 hdev->suspended = true;
1702 core->priv = hdev;
1705 ret = venus_interface_queues_init(hdev);
1712 kfree(hdev);
1720 struct venus_hfi_device *hdev = to_hfi_priv(core);
1726 mutex_lock(&hdev->lock);
1729 queue = &hdev->queues[i];
1731 IFACEQ_GET_QHDR_START_ADDR(hdev->ifaceq_table.kva, i);
1745 tbl_hdr = hdev->ifaceq_table.kva;
1757 queue = &hdev->queues[IFACEQ_DBG_IDX];
1760 sfr = hdev->sfr.kva;
1766 mutex_unlock(&hdev->lock);