hfi_packet.c 17 KB

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