hfi_packet.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
  4. * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
  5. */
  6. #include "hfi_packet.h"
  7. #include "msm_vidc_core.h"
  8. #include "msm_vidc_inst.h"
  9. #include "msm_vidc_driver.h"
  10. #include "msm_vidc_platform.h"
  11. #include "msm_vidc_debug.h"
  12. u32 get_hfi_port(struct msm_vidc_inst *inst,
  13. enum msm_vidc_port_type port)
  14. {
  15. u32 hfi_port = HFI_PORT_NONE;
  16. if (!inst) {
  17. d_vpr_e("%s: invalid params\n", __func__);
  18. return hfi_port;
  19. }
  20. if (is_decode_session(inst)) {
  21. switch(port) {
  22. case INPUT_PORT:
  23. case INPUT_META_PORT:
  24. hfi_port = HFI_PORT_BITSTREAM;
  25. break;
  26. case OUTPUT_PORT:
  27. case OUTPUT_META_PORT:
  28. hfi_port = HFI_PORT_RAW;
  29. break;
  30. default:
  31. i_vpr_e(inst, "%s: invalid port type %d\n",
  32. __func__, port);
  33. break;
  34. }
  35. } else if (is_encode_session(inst)) {
  36. switch (port) {
  37. case INPUT_PORT:
  38. case INPUT_META_PORT:
  39. hfi_port = HFI_PORT_RAW;
  40. break;
  41. case OUTPUT_PORT:
  42. case OUTPUT_META_PORT:
  43. hfi_port = HFI_PORT_BITSTREAM;
  44. break;
  45. default:
  46. i_vpr_e(inst, "%s: invalid port type %d\n",
  47. __func__, port);
  48. break;
  49. }
  50. } else {
  51. i_vpr_e(inst, "%s: invalid domain %#x\n",
  52. __func__, inst->domain);
  53. }
  54. return hfi_port;
  55. }
  56. u32 get_hfi_port_from_buffer_type(struct msm_vidc_inst *inst,
  57. enum msm_vidc_buffer_type buffer_type)
  58. {
  59. u32 hfi_port = HFI_PORT_NONE;
  60. if (!inst) {
  61. d_vpr_e("%s: invalid params\n", __func__);
  62. return hfi_port;
  63. }
  64. if (is_decode_session(inst)) {
  65. switch(buffer_type) {
  66. case MSM_VIDC_BUF_INPUT:
  67. case MSM_VIDC_BUF_INPUT_META:
  68. case MSM_VIDC_BUF_BIN:
  69. case MSM_VIDC_BUF_COMV:
  70. case MSM_VIDC_BUF_NON_COMV:
  71. case MSM_VIDC_BUF_LINE:
  72. case MSM_VIDC_BUF_PARTIAL_DATA:
  73. hfi_port = HFI_PORT_BITSTREAM;
  74. break;
  75. case MSM_VIDC_BUF_OUTPUT:
  76. case MSM_VIDC_BUF_OUTPUT_META:
  77. case MSM_VIDC_BUF_DPB:
  78. hfi_port = HFI_PORT_RAW;
  79. break;
  80. case MSM_VIDC_BUF_PERSIST:
  81. hfi_port = HFI_PORT_NONE;
  82. break;
  83. default:
  84. i_vpr_e(inst, "%s: invalid buffer type %d\n",
  85. __func__, buffer_type);
  86. break;
  87. }
  88. } else if (is_encode_session(inst)) {
  89. switch (buffer_type) {
  90. case MSM_VIDC_BUF_INPUT:
  91. case MSM_VIDC_BUF_INPUT_META:
  92. case MSM_VIDC_BUF_VPSS:
  93. hfi_port = HFI_PORT_RAW;
  94. break;
  95. case MSM_VIDC_BUF_OUTPUT:
  96. case MSM_VIDC_BUF_OUTPUT_META:
  97. case MSM_VIDC_BUF_BIN:
  98. case MSM_VIDC_BUF_COMV:
  99. case MSM_VIDC_BUF_NON_COMV:
  100. case MSM_VIDC_BUF_LINE:
  101. case MSM_VIDC_BUF_DPB:
  102. hfi_port = HFI_PORT_BITSTREAM;
  103. break;
  104. case MSM_VIDC_BUF_ARP:
  105. hfi_port = HFI_PORT_NONE;
  106. break;
  107. default:
  108. i_vpr_e(inst, "%s: invalid buffer type %d\n",
  109. __func__, buffer_type);
  110. break;
  111. }
  112. } else {
  113. i_vpr_e(inst, "%s: invalid domain %#x\n",
  114. __func__, inst->domain);
  115. }
  116. return hfi_port;
  117. }
  118. u32 hfi_buf_type_from_driver(enum msm_vidc_domain_type domain,
  119. enum msm_vidc_buffer_type buffer_type)
  120. {
  121. switch (buffer_type) {
  122. case MSM_VIDC_BUF_INPUT:
  123. if (domain == MSM_VIDC_DECODER)
  124. return HFI_BUFFER_BITSTREAM;
  125. else
  126. return HFI_BUFFER_RAW;
  127. case MSM_VIDC_BUF_OUTPUT:
  128. if (domain == MSM_VIDC_DECODER)
  129. return HFI_BUFFER_RAW;
  130. else
  131. return HFI_BUFFER_BITSTREAM;
  132. case MSM_VIDC_BUF_INPUT_META:
  133. case MSM_VIDC_BUF_OUTPUT_META:
  134. return HFI_BUFFER_METADATA;
  135. case MSM_VIDC_BUF_BIN:
  136. return HFI_BUFFER_BIN;
  137. case MSM_VIDC_BUF_ARP:
  138. return HFI_BUFFER_ARP;
  139. case MSM_VIDC_BUF_COMV:
  140. return HFI_BUFFER_COMV;
  141. case MSM_VIDC_BUF_NON_COMV:
  142. return HFI_BUFFER_NON_COMV;
  143. case MSM_VIDC_BUF_LINE:
  144. return HFI_BUFFER_LINE;
  145. case MSM_VIDC_BUF_DPB:
  146. return HFI_BUFFER_DPB;
  147. case MSM_VIDC_BUF_PERSIST:
  148. return HFI_BUFFER_PERSIST;
  149. case MSM_VIDC_BUF_VPSS:
  150. return HFI_BUFFER_VPSS;
  151. case MSM_VIDC_BUF_PARTIAL_DATA:
  152. return HFI_BUFFER_PARTIAL_DATA;
  153. default:
  154. d_vpr_e("invalid buffer type %d\n",
  155. buffer_type);
  156. return 0;
  157. }
  158. }
  159. u32 hfi_buf_type_to_driver(enum msm_vidc_domain_type domain,
  160. enum hfi_buffer_type buffer_type, enum hfi_packet_port_type port_type)
  161. {
  162. switch (buffer_type) {
  163. case HFI_BUFFER_BITSTREAM:
  164. if (domain == MSM_VIDC_DECODER)
  165. return MSM_VIDC_BUF_INPUT;
  166. else
  167. return MSM_VIDC_BUF_OUTPUT;
  168. case HFI_BUFFER_RAW:
  169. if (domain == MSM_VIDC_DECODER)
  170. return MSM_VIDC_BUF_OUTPUT;
  171. else
  172. return MSM_VIDC_BUF_INPUT;
  173. case HFI_BUFFER_METADATA:
  174. if (domain == MSM_VIDC_DECODER)
  175. if (port_type == HFI_PORT_BITSTREAM)
  176. return MSM_VIDC_BUF_INPUT_META;
  177. else
  178. return MSM_VIDC_BUF_OUTPUT_META;
  179. else
  180. if (port_type == HFI_PORT_BITSTREAM)
  181. return MSM_VIDC_BUF_OUTPUT_META;
  182. else
  183. return MSM_VIDC_BUF_INPUT_META;
  184. case HFI_BUFFER_BIN:
  185. return MSM_VIDC_BUF_BIN;
  186. case HFI_BUFFER_ARP:
  187. return MSM_VIDC_BUF_ARP;
  188. case HFI_BUFFER_COMV:
  189. return MSM_VIDC_BUF_COMV;
  190. case HFI_BUFFER_NON_COMV:
  191. return MSM_VIDC_BUF_NON_COMV;
  192. case HFI_BUFFER_LINE:
  193. return MSM_VIDC_BUF_LINE;
  194. case HFI_BUFFER_DPB:
  195. return MSM_VIDC_BUF_DPB;
  196. case HFI_BUFFER_PERSIST:
  197. return MSM_VIDC_BUF_PERSIST;
  198. case HFI_BUFFER_VPSS:
  199. return MSM_VIDC_BUF_VPSS;
  200. case HFI_BUFFER_PARTIAL_DATA:
  201. return MSM_VIDC_BUF_PARTIAL_DATA;
  202. default:
  203. d_vpr_e("invalid buffer type %d\n",
  204. buffer_type);
  205. return 0;
  206. }
  207. }
  208. u32 get_hfi_codec(struct msm_vidc_inst *inst)
  209. {
  210. if (!inst) {
  211. d_vpr_e("%s: invalid params\n", __func__);
  212. return 0;
  213. }
  214. switch (inst->codec) {
  215. case MSM_VIDC_H264:
  216. if (inst->domain == MSM_VIDC_ENCODER)
  217. return HFI_CODEC_ENCODE_AVC;
  218. else
  219. return HFI_CODEC_DECODE_AVC;
  220. case MSM_VIDC_HEVC:
  221. case MSM_VIDC_HEIC:
  222. if (inst->domain == MSM_VIDC_ENCODER)
  223. return HFI_CODEC_ENCODE_HEVC;
  224. else
  225. return HFI_CODEC_DECODE_HEVC;
  226. case MSM_VIDC_VP9:
  227. return HFI_CODEC_DECODE_VP9;
  228. case MSM_VIDC_AV1:
  229. return HFI_CODEC_DECODE_AV1;
  230. default:
  231. i_vpr_e(inst, "invalid codec %d, domain %d\n",
  232. inst->codec, inst->domain);
  233. return 0;
  234. }
  235. }
  236. u32 get_hfi_colorformat(struct msm_vidc_inst *inst,
  237. enum msm_vidc_colorformat_type colorformat)
  238. {
  239. u32 hfi_colorformat = HFI_COLOR_FMT_NV12_UBWC;
  240. if (!inst) {
  241. d_vpr_e("%s: invalid params\n", __func__);
  242. return hfi_colorformat;
  243. }
  244. switch(colorformat) {
  245. case MSM_VIDC_FMT_NV12:
  246. hfi_colorformat = HFI_COLOR_FMT_NV12;
  247. break;
  248. case MSM_VIDC_FMT_NV12C:
  249. hfi_colorformat = HFI_COLOR_FMT_NV12_UBWC;
  250. break;
  251. case MSM_VIDC_FMT_P010:
  252. hfi_colorformat = HFI_COLOR_FMT_P010;
  253. break;
  254. case MSM_VIDC_FMT_TP10C:
  255. hfi_colorformat = HFI_COLOR_FMT_TP10_UBWC;
  256. break;
  257. case MSM_VIDC_FMT_RGBA8888:
  258. hfi_colorformat = HFI_COLOR_FMT_RGBA8888;
  259. break;
  260. case MSM_VIDC_FMT_RGBA8888C:
  261. hfi_colorformat = HFI_COLOR_FMT_RGBA8888_UBWC;
  262. break;
  263. case MSM_VIDC_FMT_NV21:
  264. hfi_colorformat = HFI_COLOR_FMT_NV21;
  265. break;
  266. default:
  267. i_vpr_e(inst, "%s: invalid colorformat %d\n",
  268. __func__, colorformat);
  269. break;
  270. }
  271. return hfi_colorformat;
  272. }
  273. static u32 get_hfi_region_flag(enum msm_vidc_buffer_region region)
  274. {
  275. switch (region) {
  276. case MSM_VIDC_NON_SECURE:
  277. return HFI_BUF_HOST_FLAGS_CB_NON_SECURE;
  278. case MSM_VIDC_NON_SECURE_PIXEL:
  279. return HFI_BUF_HOST_FLAGS_CB_NON_SECURE_PIXEL;
  280. case MSM_VIDC_SECURE_PIXEL:
  281. return HFI_BUF_HOST_FLAGS_CB_SECURE_PIXEL;
  282. case MSM_VIDC_SECURE_NONPIXEL:
  283. return HFI_BUF_HOST_FLAGS_CB_SECURE_NON_PIXEL;
  284. case MSM_VIDC_SECURE_BITSTREAM:
  285. return HFI_BUF_HOST_FLAGS_CB_SECURE_BITSTREAM;
  286. case MSM_VIDC_REGION_MAX:
  287. case MSM_VIDC_REGION_NONE:
  288. default:
  289. return HFI_BUF_HOST_FLAG_NONE;
  290. }
  291. }
  292. int get_hfi_buffer(struct msm_vidc_inst *inst,
  293. struct msm_vidc_buffer *buffer, struct hfi_buffer *buf)
  294. {
  295. if (!inst || !buffer || !buf) {
  296. d_vpr_e("%s: invalid params\n", __func__);
  297. return -EINVAL;
  298. }
  299. memset(buf, 0, sizeof(struct hfi_buffer));
  300. buf->type = hfi_buf_type_from_driver(inst->domain, buffer->type);
  301. buf->index = buffer->index;
  302. buf->base_address = buffer->device_addr;
  303. buf->addr_offset = 0;
  304. buf->buffer_size = buffer->buffer_size;
  305. buf->data_offset = buffer->data_offset;
  306. buf->data_size = buffer->data_size;
  307. if (buffer->attr & MSM_VIDC_ATTR_READ_ONLY)
  308. buf->flags |= HFI_BUF_HOST_FLAG_READONLY;
  309. if (buffer->attr & MSM_VIDC_ATTR_PENDING_RELEASE)
  310. buf->flags |= HFI_BUF_HOST_FLAG_RELEASE;
  311. if (buffer->flags & MSM_VIDC_BUF_FLAG_CODECCONFIG)
  312. buf->flags |= HFI_BUF_HOST_FLAG_CODEC_CONFIG;
  313. buf->flags |= get_hfi_region_flag(buffer->region);
  314. buf->timestamp = buffer->timestamp;
  315. return 0;
  316. }
  317. int hfi_create_header(u8 *packet, u32 packet_size, u32 session_id,
  318. u32 header_id)
  319. {
  320. struct hfi_header *hdr = (struct hfi_header *)packet;
  321. if (!packet || packet_size < sizeof(struct hfi_header)) {
  322. d_vpr_e("%s: invalid params\n", __func__);
  323. return -EINVAL;
  324. }
  325. memset(hdr, 0, sizeof(struct hfi_header));
  326. hdr->size = sizeof(struct hfi_header);
  327. hdr->session_id = session_id;
  328. hdr->header_id = header_id;
  329. hdr->num_packets = 0;
  330. return 0;
  331. }
  332. int hfi_create_packet(u8 *packet, u32 packet_size,
  333. u32 pkt_type, u32 pkt_flags, u32 payload_type, u32 port,
  334. u32 packet_id, void *payload, u32 payload_size)
  335. {
  336. struct hfi_header *hdr;
  337. struct hfi_packet *pkt;
  338. u32 pkt_size;
  339. if (!packet) {
  340. d_vpr_e("%s: invalid params\n", __func__);
  341. return -EINVAL;
  342. }
  343. hdr = (struct hfi_header *)packet;
  344. if (hdr->size < sizeof(struct hfi_header)) {
  345. d_vpr_e("%s: invalid hdr size %d\n", __func__, hdr->size);
  346. return -EINVAL;
  347. }
  348. pkt = (struct hfi_packet *)(packet + hdr->size);
  349. pkt_size = sizeof(struct hfi_packet) + payload_size;
  350. if (packet_size < hdr->size + pkt_size) {
  351. d_vpr_e("%s: invalid packet_size %d, %d %d\n",
  352. __func__, packet_size, hdr->size, pkt_size);
  353. return -EINVAL;
  354. }
  355. memset(pkt, 0, pkt_size);
  356. pkt->size = pkt_size;
  357. pkt->type = pkt_type;
  358. pkt->flags = pkt_flags;
  359. pkt->payload_info = payload_type;
  360. pkt->port = port;
  361. pkt->packet_id = packet_id;
  362. if (payload_size)
  363. memcpy((u8 *)pkt + sizeof(struct hfi_packet),
  364. payload, payload_size);
  365. hdr->num_packets++;
  366. hdr->size += pkt->size;
  367. return 0;
  368. }
  369. int hfi_packet_sys_init(struct msm_vidc_core *core,
  370. u8 *pkt, u32 pkt_size)
  371. {
  372. int rc = 0;
  373. u32 payload = 0;
  374. if (!core || !pkt) {
  375. d_vpr_e("%s: Invalid params\n", __func__);
  376. return -EINVAL;
  377. }
  378. rc = hfi_create_header(pkt, pkt_size,
  379. 0 /*session_id*/,
  380. core->header_id++);
  381. if (rc)
  382. goto err_sys_init;
  383. /* HFI_CMD_SYSTEM_INIT */
  384. payload = HFI_VIDEO_ARCH_LX;
  385. d_vpr_h("%s: arch %d\n", __func__, payload);
  386. core->sys_init_id = core->packet_id++;
  387. rc = hfi_create_packet(pkt, pkt_size,
  388. HFI_CMD_INIT,
  389. (HFI_HOST_FLAGS_RESPONSE_REQUIRED |
  390. HFI_HOST_FLAGS_INTR_REQUIRED |
  391. HFI_HOST_FLAGS_NON_DISCARDABLE),
  392. HFI_PAYLOAD_U32,
  393. HFI_PORT_NONE,
  394. core->sys_init_id,
  395. &payload,
  396. sizeof(u32));
  397. if (rc)
  398. goto err_sys_init;
  399. /* HFI_PROP_UBWC_MAX_CHANNELS */
  400. payload = core->platform->data.ubwc_config->max_channels;
  401. d_vpr_h("%s: ubwc max channels %d\n", __func__, payload);
  402. rc = hfi_create_packet(pkt, pkt_size,
  403. HFI_PROP_UBWC_MAX_CHANNELS,
  404. HFI_HOST_FLAGS_NONE,
  405. HFI_PAYLOAD_U32,
  406. HFI_PORT_NONE,
  407. core->packet_id++,
  408. &payload,
  409. sizeof(u32));
  410. if (rc)
  411. goto err_sys_init;
  412. /* HFI_PROP_UBWC_MAL_LENGTH */
  413. payload = core->platform->data.ubwc_config->mal_length;
  414. d_vpr_h("%s: ubwc mal length %d\n", __func__, payload);
  415. rc = hfi_create_packet(pkt, pkt_size,
  416. HFI_PROP_UBWC_MAL_LENGTH,
  417. HFI_HOST_FLAGS_NONE,
  418. HFI_PAYLOAD_U32,
  419. HFI_PORT_NONE,
  420. core->packet_id++,
  421. &payload,
  422. sizeof(u32));
  423. if (rc)
  424. goto err_sys_init;
  425. /* HFI_PROP_UBWC_HBB */
  426. payload = core->platform->data.ubwc_config->highest_bank_bit;
  427. d_vpr_h("%s: ubwc hbb %d\n", __func__, payload);
  428. rc = hfi_create_packet(pkt, pkt_size,
  429. HFI_PROP_UBWC_HBB,
  430. HFI_HOST_FLAGS_NONE,
  431. HFI_PAYLOAD_U32,
  432. HFI_PORT_NONE,
  433. core->packet_id++,
  434. &payload,
  435. sizeof(u32));
  436. if (rc)
  437. goto err_sys_init;
  438. /* HFI_PROP_UBWC_BANK_SWZL_LEVEL1 */
  439. payload = core->platform->data.ubwc_config->bank_swzl_level;
  440. d_vpr_h("%s: ubwc swzl1 %d\n", __func__, payload);
  441. rc = hfi_create_packet(pkt, pkt_size,
  442. HFI_PROP_UBWC_BANK_SWZL_LEVEL1,
  443. HFI_HOST_FLAGS_NONE,
  444. HFI_PAYLOAD_U32,
  445. HFI_PORT_NONE,
  446. core->packet_id++,
  447. &payload,
  448. sizeof(u32));
  449. if (rc)
  450. goto err_sys_init;
  451. /* HFI_PROP_UBWC_BANK_SWZL_LEVEL2 */
  452. payload = core->platform->data.ubwc_config->bank_swz2_level;
  453. d_vpr_h("%s: ubwc swzl2 %d\n", __func__, payload);
  454. rc = hfi_create_packet(pkt, pkt_size,
  455. HFI_PROP_UBWC_BANK_SWZL_LEVEL2,
  456. HFI_HOST_FLAGS_NONE,
  457. HFI_PAYLOAD_U32,
  458. HFI_PORT_NONE,
  459. core->packet_id++,
  460. &payload,
  461. sizeof(u32));
  462. if (rc)
  463. goto err_sys_init;
  464. /* HFI_PROP_UBWC_BANK_SWZL_LEVEL3 */
  465. payload = core->platform->data.ubwc_config->bank_swz3_level;
  466. d_vpr_h("%s: ubwc swzl3 %d\n", __func__, payload);
  467. rc = hfi_create_packet(pkt, pkt_size,
  468. HFI_PROP_UBWC_BANK_SWZL_LEVEL3,
  469. HFI_HOST_FLAGS_NONE,
  470. HFI_PAYLOAD_U32,
  471. HFI_PORT_NONE,
  472. core->packet_id++,
  473. &payload,
  474. sizeof(u32));
  475. if (rc)
  476. goto err_sys_init;
  477. /* HFI_PROP_UBWC_BANK_SPREADING */
  478. payload = core->platform->data.ubwc_config->bank_spreading;
  479. d_vpr_h("%s: ubwc bank spreading %d\n", __func__, payload);
  480. rc = hfi_create_packet(pkt, pkt_size,
  481. HFI_PROP_UBWC_BANK_SPREADING,
  482. HFI_HOST_FLAGS_NONE,
  483. HFI_PAYLOAD_U32,
  484. HFI_PORT_NONE,
  485. core->packet_id++,
  486. &payload,
  487. sizeof(u32));
  488. if (rc)
  489. goto err_sys_init;
  490. d_vpr_h("System init packet created\n");
  491. return rc;
  492. err_sys_init:
  493. d_vpr_e("%s: create packet failed\n", __func__);
  494. return rc;
  495. }
  496. int hfi_packet_image_version(struct msm_vidc_core *core,
  497. u8 *pkt, u32 pkt_size)
  498. {
  499. int rc = 0;
  500. if (!core || !pkt) {
  501. d_vpr_e("%s: Invalid params\n", __func__);
  502. return -EINVAL;
  503. }
  504. rc = hfi_create_header(pkt, pkt_size,
  505. 0 /*session_id*/,
  506. core->header_id++);
  507. if (rc)
  508. goto err_img_version;
  509. /* HFI_PROP_IMAGE_VERSION */
  510. rc = hfi_create_packet(pkt, pkt_size,
  511. HFI_PROP_IMAGE_VERSION,
  512. (HFI_HOST_FLAGS_RESPONSE_REQUIRED |
  513. HFI_HOST_FLAGS_INTR_REQUIRED |
  514. HFI_HOST_FLAGS_GET_PROPERTY),
  515. HFI_PAYLOAD_NONE,
  516. HFI_PORT_NONE,
  517. core->packet_id++,
  518. NULL, 0);
  519. if (rc)
  520. goto err_img_version;
  521. d_vpr_h("Image version packet created\n");
  522. return rc;
  523. err_img_version:
  524. d_vpr_e("%s: create packet failed\n", __func__);
  525. return rc;
  526. }
  527. int hfi_packet_sys_pc_prep(struct msm_vidc_core *core,
  528. u8 *pkt, u32 pkt_size)
  529. {
  530. int rc = 0;
  531. if (!core || !pkt) {
  532. d_vpr_e("%s: Invalid params\n", __func__);
  533. return -EINVAL;
  534. }
  535. rc = hfi_create_header(pkt, pkt_size,
  536. 0 /*session_id*/,
  537. core->header_id++);
  538. if (rc)
  539. goto err_sys_pc;
  540. /* HFI_CMD_POWER_COLLAPSE */
  541. rc = hfi_create_packet(pkt, pkt_size,
  542. HFI_CMD_POWER_COLLAPSE,
  543. HFI_HOST_FLAGS_NONE,
  544. HFI_PAYLOAD_NONE,
  545. HFI_PORT_NONE,
  546. core->packet_id++,
  547. NULL, 0);
  548. if (rc)
  549. goto err_sys_pc;
  550. d_vpr_h("Power collapse packet created\n");
  551. return rc;
  552. err_sys_pc:
  553. d_vpr_e("%s: create packet failed\n", __func__);
  554. return rc;
  555. }
  556. int hfi_packet_sys_debug_config(struct msm_vidc_core *core,
  557. u8 *pkt, u32 pkt_size, u32 debug_config)
  558. {
  559. int rc = 0;
  560. u32 payload = 0;
  561. if (!core || !pkt) {
  562. d_vpr_e("%s: Invalid params\n", __func__);
  563. return -EINVAL;
  564. }
  565. rc = hfi_create_header(pkt, pkt_size,
  566. 0 /*session_id*/,
  567. core->header_id++);
  568. if (rc)
  569. goto err_debug;
  570. /* HFI_PROP_DEBUG_CONFIG */
  571. payload = 0; /*TODO:Change later*/
  572. rc = hfi_create_packet(pkt, pkt_size,
  573. HFI_PROP_DEBUG_CONFIG,
  574. HFI_HOST_FLAGS_NONE,
  575. HFI_PAYLOAD_U32_ENUM,
  576. HFI_PORT_NONE,
  577. core->packet_id++,
  578. &payload,
  579. sizeof(u32));
  580. if (rc)
  581. goto err_debug;
  582. /* HFI_PROP_DEBUG_LOG_LEVEL */
  583. payload = debug_config; /*TODO:Change later*/
  584. rc = hfi_create_packet(pkt, pkt_size,
  585. HFI_PROP_DEBUG_LOG_LEVEL,
  586. HFI_HOST_FLAGS_NONE,
  587. HFI_PAYLOAD_U32_ENUM,
  588. HFI_PORT_NONE,
  589. core->packet_id++,
  590. &payload,
  591. sizeof(u32));
  592. if (rc)
  593. goto err_debug;
  594. err_debug:
  595. if (rc)
  596. d_vpr_e("%s: create packet failed\n", __func__);
  597. return rc;
  598. }
  599. int hfi_packet_session_command(struct msm_vidc_inst *inst,
  600. u32 pkt_type, u32 flags, u32 port, u32 session_id,
  601. u32 payload_type, void *payload, u32 payload_size)
  602. {
  603. int rc = 0;
  604. struct msm_vidc_core *core;
  605. if (!inst || !inst->core || !inst->packet) {
  606. d_vpr_e("%s: Invalid params\n", __func__);
  607. return -EINVAL;
  608. }
  609. core = inst->core;
  610. rc = hfi_create_header(inst->packet, inst->packet_size,
  611. session_id,
  612. core->header_id++);
  613. if (rc)
  614. goto err_cmd;
  615. rc = hfi_create_packet(inst->packet,
  616. inst->packet_size,
  617. pkt_type,
  618. flags,
  619. payload_type,
  620. port,
  621. core->packet_id++,
  622. payload,
  623. payload_size);
  624. if (rc)
  625. goto err_cmd;
  626. i_vpr_h(inst, "Command packet 0x%x created\n", pkt_type);
  627. return rc;
  628. err_cmd:
  629. i_vpr_e(inst, "%s: create packet failed\n", __func__);
  630. return rc;
  631. }
  632. int hfi_packet_sys_intraframe_powercollapse(struct msm_vidc_core* core,
  633. u8* pkt, u32 pkt_size, u32 enable)
  634. {
  635. int rc = 0;
  636. u32 payload = 0;
  637. if (!core || !pkt) {
  638. d_vpr_e("%s: Invalid params\n", __func__);
  639. return -EINVAL;
  640. }
  641. rc = hfi_create_header(pkt, pkt_size,
  642. 0 /*session_id*/,
  643. core->header_id++);
  644. if (rc)
  645. goto err;
  646. /* HFI_PROP_INTRA_FRAME_POWER_COLLAPSE */
  647. payload = enable;
  648. d_vpr_h("%s: intra frame power collapse %d\n", __func__, payload);
  649. rc = hfi_create_packet(pkt, pkt_size,
  650. HFI_PROP_INTRA_FRAME_POWER_COLLAPSE,
  651. HFI_HOST_FLAGS_NONE,
  652. HFI_PAYLOAD_U32,
  653. HFI_PORT_NONE,
  654. core->packet_id++,
  655. &payload,
  656. sizeof(u32));
  657. if (rc)
  658. goto err;
  659. d_vpr_h("IFPC packet created\n");
  660. return rc;
  661. err:
  662. d_vpr_e("%s: create packet failed\n", __func__);
  663. return rc;
  664. }