msm_vidc.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
  4. */
  5. #include <linux/types.h>
  6. #include <linux/hash.h>
  7. #include "msm_vidc_core.h"
  8. #include "msm_vidc_inst.h"
  9. #include "msm_vdec.h"
  10. #include "msm_venc.h"
  11. #include "msm_vidc_internal.h"
  12. #include "msm_vidc_driver.h"
  13. #include "msm_vidc_vb2.h"
  14. #include "msm_vidc_v4l2.h"
  15. #include "msm_vidc_debug.h"
  16. #include "msm_vidc_control.h"
  17. #include "msm_vidc_power.h"
  18. #include "msm_vidc_memory.h"
  19. #include "venus_hfi_response.h"
  20. #include "msm_vidc.h"
  21. #define MSM_VIDC_DRV_NAME "msm_vidc_driver"
  22. #define MSM_VIDC_BUS_NAME "platform:msm_vidc_bus"
  23. /* kernel/msm-4.19 */
  24. #define MSM_VIDC_VERSION ((5 << 16) + (10 << 8) + 0)
  25. #define MAX_EVENTS 30
  26. static inline bool valid_v4l2_buffer(struct v4l2_buffer *b,
  27. struct msm_vidc_inst *inst)
  28. {
  29. if (b->type == INPUT_MPLANE || b->type == OUTPUT_MPLANE)
  30. return b->length > 0;
  31. else if (b->type == INPUT_META_PLANE || b->type == OUTPUT_META_PLANE)
  32. return true;
  33. return false;
  34. }
  35. static int get_poll_flags(struct msm_vidc_inst *inst, u32 port)
  36. {
  37. int poll = 0;
  38. struct vb2_queue *q = NULL;
  39. struct vb2_buffer *vb = NULL;
  40. unsigned long flags = 0;
  41. if (!inst || port >= MAX_PORT) {
  42. d_vpr_e("%s: invalid params, inst %pK, port %d\n",
  43. __func__, inst, port);
  44. return poll;
  45. }
  46. q = &inst->vb2q[port];
  47. spin_lock_irqsave(&q->done_lock, flags);
  48. if (!list_empty(&q->done_list))
  49. vb = list_first_entry(&q->done_list, struct vb2_buffer,
  50. done_entry);
  51. if (vb && (vb->state == VB2_BUF_STATE_DONE ||
  52. vb->state == VB2_BUF_STATE_ERROR)) {
  53. if (port == OUTPUT_PORT || port == OUTPUT_META_PORT)
  54. poll |= POLLIN | POLLRDNORM;
  55. else if (port == INPUT_PORT || port == INPUT_META_PORT)
  56. poll |= POLLOUT | POLLWRNORM;
  57. }
  58. spin_unlock_irqrestore(&q->done_lock, flags);
  59. return poll;
  60. }
  61. int msm_vidc_poll(void *instance, struct file *filp,
  62. struct poll_table_struct *wait)
  63. {
  64. int poll = 0;
  65. struct msm_vidc_inst *inst = instance;
  66. if (!inst) {
  67. d_vpr_e("%s: invalid params\n", __func__);
  68. return POLLERR;
  69. }
  70. if (is_session_error(inst)) {
  71. i_vpr_e(inst, "%s: inst in error state\n", __func__);
  72. return POLLERR;
  73. }
  74. poll_wait(filp, &inst->event_handler.wait, wait);
  75. poll_wait(filp, &inst->vb2q[INPUT_META_PORT].done_wq, wait);
  76. poll_wait(filp, &inst->vb2q[OUTPUT_META_PORT].done_wq, wait);
  77. poll_wait(filp, &inst->vb2q[INPUT_PORT].done_wq, wait);
  78. poll_wait(filp, &inst->vb2q[OUTPUT_PORT].done_wq, wait);
  79. if (v4l2_event_pending(&inst->event_handler))
  80. poll |= POLLPRI;
  81. poll |= get_poll_flags(inst, INPUT_META_PORT);
  82. poll |= get_poll_flags(inst, OUTPUT_META_PORT);
  83. poll |= get_poll_flags(inst, INPUT_PORT);
  84. poll |= get_poll_flags(inst, OUTPUT_PORT);
  85. return poll;
  86. }
  87. EXPORT_SYMBOL(msm_vidc_poll);
  88. int msm_vidc_querycap(void *instance, struct v4l2_capability *cap)
  89. {
  90. struct msm_vidc_inst *inst = instance;
  91. if (!inst || !cap) {
  92. d_vpr_e("%s: invalid params\n", __func__);
  93. return -EINVAL;
  94. }
  95. strlcpy(cap->driver, MSM_VIDC_DRV_NAME, sizeof(cap->driver));
  96. strlcpy(cap->bus_info, MSM_VIDC_BUS_NAME, sizeof(cap->bus_info));
  97. cap->version = MSM_VIDC_VERSION;
  98. memset(cap->reserved, 0, sizeof(cap->reserved));
  99. if (inst->domain == MSM_VIDC_DECODER)
  100. strlcpy(cap->card, "msm_vidc_decoder", sizeof(cap->card));
  101. else if (inst->domain == MSM_VIDC_ENCODER)
  102. strlcpy(cap->card, "msm_vidc_encoder", sizeof(cap->card));
  103. else
  104. return -EINVAL;
  105. return 0;
  106. }
  107. EXPORT_SYMBOL(msm_vidc_querycap);
  108. int msm_vidc_enum_fmt(void *instance, struct v4l2_fmtdesc *f)
  109. {
  110. struct msm_vidc_inst *inst = instance;
  111. if (!inst || !f) {
  112. d_vpr_e("%s: invalid params\n", __func__);
  113. return -EINVAL;
  114. }
  115. if (inst->domain == MSM_VIDC_DECODER)
  116. return msm_vdec_enum_fmt(inst, f);
  117. if (inst->domain == MSM_VIDC_ENCODER)
  118. return msm_venc_enum_fmt(inst, f);
  119. return -EINVAL;
  120. }
  121. EXPORT_SYMBOL(msm_vidc_enum_fmt);
  122. int msm_vidc_query_ctrl(void *instance, struct v4l2_queryctrl *q_ctrl)
  123. {
  124. int rc = 0;
  125. struct msm_vidc_inst *inst = instance;
  126. struct v4l2_ctrl *ctrl;
  127. if (!inst || !q_ctrl) {
  128. d_vpr_e("%s: invalid params %pK %pK\n",
  129. __func__, inst, q_ctrl);
  130. return -EINVAL;
  131. }
  132. ctrl = v4l2_ctrl_find(&inst->ctrl_handler, q_ctrl->id);
  133. if (!ctrl) {
  134. i_vpr_e(inst, "%s: get_ctrl failed for id %d\n",
  135. __func__, q_ctrl->id);
  136. return -EINVAL;
  137. }
  138. q_ctrl->minimum = ctrl->minimum;
  139. q_ctrl->maximum = ctrl->maximum;
  140. q_ctrl->default_value = ctrl->default_value;
  141. q_ctrl->flags = 0;
  142. q_ctrl->step = ctrl->step;
  143. i_vpr_h(inst,
  144. "query ctrl: %s: min %d, max %d, default %d step %d flags %#x\n",
  145. ctrl->name, q_ctrl->minimum, q_ctrl->maximum,
  146. q_ctrl->default_value, q_ctrl->step, q_ctrl->flags);
  147. return rc;
  148. }
  149. EXPORT_SYMBOL(msm_vidc_query_ctrl);
  150. int msm_vidc_query_menu(void *instance, struct v4l2_querymenu *qmenu)
  151. {
  152. int rc = 0;
  153. struct msm_vidc_inst *inst = instance;
  154. struct v4l2_ctrl *ctrl;
  155. if (!inst || !qmenu) {
  156. d_vpr_e("%s: invalid params %pK %pK\n",
  157. __func__, inst, qmenu);
  158. return -EINVAL;
  159. }
  160. ctrl = v4l2_ctrl_find(&inst->ctrl_handler, qmenu->id);
  161. if (!ctrl) {
  162. i_vpr_e(inst, "%s: get_ctrl failed for id %d\n",
  163. __func__, qmenu->id);
  164. return -EINVAL;
  165. }
  166. if (ctrl->type != V4L2_CTRL_TYPE_MENU) {
  167. i_vpr_e(inst, "%s: ctrl: %s: type (%d) is not MENU type\n",
  168. __func__, ctrl->name, ctrl->type);
  169. return -EINVAL;
  170. }
  171. if (qmenu->index < ctrl->minimum || qmenu->index > ctrl->maximum)
  172. return -EINVAL;
  173. if (ctrl->menu_skip_mask & (1 << qmenu->index))
  174. rc = -EINVAL;
  175. i_vpr_h(inst,
  176. "%s: ctrl: %s: min %lld, max %lld, menu_skip_mask %#x, qmenu: id %u, index %d, %s\n",
  177. __func__, ctrl->name, ctrl->minimum, ctrl->maximum,
  178. ctrl->menu_skip_mask, qmenu->id, qmenu->index,
  179. rc ? "not supported" : "supported");
  180. return rc;
  181. }
  182. EXPORT_SYMBOL(msm_vidc_query_menu);
  183. int msm_vidc_try_fmt(void *instance, struct v4l2_format *f)
  184. {
  185. int rc = 0;
  186. struct msm_vidc_inst *inst = instance;
  187. if (!inst || !f) {
  188. d_vpr_e("%s: invalid params\n", __func__);
  189. return -EINVAL;
  190. }
  191. if (!msm_vidc_allow_s_fmt(inst, f->type))
  192. return -EBUSY;
  193. if (inst->domain == MSM_VIDC_DECODER)
  194. rc = msm_vdec_try_fmt(inst, f);
  195. if (inst->domain == MSM_VIDC_ENCODER)
  196. rc = msm_venc_try_fmt(inst, f);
  197. if (rc)
  198. i_vpr_e(inst, "%s: try_fmt(%d) failed %d\n",
  199. __func__, f->type, rc);
  200. return rc;
  201. }
  202. EXPORT_SYMBOL(msm_vidc_try_fmt);
  203. int msm_vidc_s_fmt(void *instance, struct v4l2_format *f)
  204. {
  205. int rc = 0;
  206. struct msm_vidc_inst *inst = instance;
  207. if (!inst || !f) {
  208. d_vpr_e("%s: invalid params\n", __func__);
  209. return -EINVAL;
  210. }
  211. if (!msm_vidc_allow_s_fmt(inst, f->type))
  212. return -EBUSY;
  213. if (inst->domain == MSM_VIDC_DECODER)
  214. rc = msm_vdec_s_fmt(inst, f);
  215. if (inst->domain == MSM_VIDC_ENCODER)
  216. rc = msm_venc_s_fmt(inst, f);
  217. if (rc)
  218. i_vpr_e(inst, "%s: s_fmt(%d) failed %d\n",
  219. __func__, f->type, rc);
  220. return rc;
  221. }
  222. EXPORT_SYMBOL(msm_vidc_s_fmt);
  223. int msm_vidc_g_fmt(void *instance, struct v4l2_format *f)
  224. {
  225. int rc = 0;
  226. struct msm_vidc_inst *inst = instance;
  227. if (!inst || !f) {
  228. d_vpr_e("%s: invalid params\n", __func__);
  229. return -EINVAL;
  230. }
  231. if (is_decode_session(inst))
  232. rc = msm_vdec_g_fmt(inst, f);
  233. if (is_encode_session(inst))
  234. rc = msm_venc_g_fmt(inst, f);
  235. if (rc)
  236. return rc;
  237. if (f->type == INPUT_MPLANE || f->type == OUTPUT_MPLANE)
  238. i_vpr_h(inst, "%s: type %s format %s width %d height %d size %d\n",
  239. __func__, v4l2_type_name(f->type),
  240. v4l2_pixelfmt_name(f->fmt.pix_mp.pixelformat),
  241. f->fmt.pix_mp.width, f->fmt.pix_mp.height,
  242. f->fmt.pix_mp.plane_fmt[0].sizeimage);
  243. else if (f->type == INPUT_META_PLANE || f->type == OUTPUT_META_PLANE)
  244. i_vpr_h(inst, "%s: type %s size %d\n",
  245. __func__, v4l2_type_name(f->type), f->fmt.meta.buffersize);
  246. return 0;
  247. }
  248. EXPORT_SYMBOL(msm_vidc_g_fmt);
  249. int msm_vidc_s_selection(void *instance, struct v4l2_selection *s)
  250. {
  251. int rc = 0;
  252. struct msm_vidc_inst *inst = instance;
  253. if (!inst || !s) {
  254. d_vpr_e("%s: invalid params\n", __func__);
  255. return -EINVAL;
  256. }
  257. if (is_decode_session(inst))
  258. rc = msm_vdec_s_selection(inst, s);
  259. if (is_encode_session(inst))
  260. rc = msm_venc_s_selection(inst, s);
  261. return rc;
  262. }
  263. EXPORT_SYMBOL(msm_vidc_s_selection);
  264. int msm_vidc_g_selection(void *instance, struct v4l2_selection *s)
  265. {
  266. int rc = 0;
  267. struct msm_vidc_inst *inst = instance;
  268. if (!inst || !s) {
  269. d_vpr_e("%s: invalid params\n", __func__);
  270. return -EINVAL;
  271. }
  272. if (is_decode_session(inst))
  273. rc = msm_vdec_g_selection(inst, s);
  274. if (is_encode_session(inst))
  275. rc = msm_venc_g_selection(inst, s);
  276. return rc;
  277. }
  278. EXPORT_SYMBOL(msm_vidc_g_selection);
  279. int msm_vidc_s_param(void *instance, struct v4l2_streamparm *param)
  280. {
  281. int rc = 0;
  282. struct msm_vidc_inst *inst = instance;
  283. if (!inst || !param) {
  284. d_vpr_e("%s: invalid params\n", __func__);
  285. return -EINVAL;
  286. }
  287. if (param->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
  288. param->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
  289. return -EINVAL;
  290. if (is_decode_session(inst))
  291. rc = msm_vdec_s_param(instance, param);
  292. else if (is_encode_session(inst))
  293. rc = msm_venc_s_param(instance, param);
  294. return rc;
  295. }
  296. EXPORT_SYMBOL(msm_vidc_s_param);
  297. int msm_vidc_g_param(void *instance, struct v4l2_streamparm *param)
  298. {
  299. int rc = 0;
  300. struct msm_vidc_inst *inst = instance;
  301. if (!inst || !param) {
  302. d_vpr_e("%s: invalid params\n", __func__);
  303. return -EINVAL;
  304. }
  305. if (param->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
  306. param->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
  307. return -EINVAL;
  308. if (is_decode_session(inst))
  309. rc = msm_vdec_g_param(instance, param);
  310. else if (is_encode_session(inst))
  311. rc = msm_venc_g_param(instance, param);
  312. return rc;
  313. }
  314. EXPORT_SYMBOL(msm_vidc_g_param);
  315. int msm_vidc_reqbufs(void *instance, struct v4l2_requestbuffers *b)
  316. {
  317. int rc = 0;
  318. struct msm_vidc_inst *inst = instance;
  319. int port;
  320. if (!inst || !b) {
  321. d_vpr_e("%s: invalid params\n", __func__);
  322. return -EINVAL;
  323. }
  324. if (!msm_vidc_allow_reqbufs(inst, b->type)) {
  325. rc = -EBUSY;
  326. goto exit;
  327. }
  328. port = v4l2_type_to_driver_port(inst, b->type, __func__);
  329. if (port < 0) {
  330. rc = -EINVAL;
  331. goto exit;
  332. }
  333. rc = vb2_reqbufs(&inst->vb2q[port], b);
  334. if (rc) {
  335. i_vpr_e(inst, "%s: vb2_reqbufs(%d) failed, %d\n",
  336. __func__, b->type, rc);
  337. goto exit;
  338. }
  339. exit:
  340. return rc;
  341. }
  342. EXPORT_SYMBOL(msm_vidc_reqbufs);
  343. int msm_vidc_qbuf(void *instance, struct media_device *mdev,
  344. struct v4l2_buffer *b)
  345. {
  346. int rc = 0;
  347. struct msm_vidc_inst *inst = instance;
  348. struct vb2_queue *q;
  349. u64 timestamp_us = 0;
  350. if (!inst || !inst->core || !b || !valid_v4l2_buffer(b, inst)) {
  351. d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, b);
  352. return -EINVAL;
  353. }
  354. /* Expecting non-zero filledlen on INPUT port */
  355. if (b->type == INPUT_MPLANE && !b->m.planes[0].bytesused) {
  356. i_vpr_e(inst,
  357. "%s: zero bytesused input buffer not supported\n", __func__);
  358. return -EINVAL;
  359. }
  360. q = msm_vidc_get_vb2q(inst, b->type, __func__);
  361. if (!q) {
  362. rc = -EINVAL;
  363. goto exit;
  364. }
  365. if (is_encode_session(inst) && b->type == INPUT_MPLANE) {
  366. timestamp_us = (u64)((b->timestamp.tv_sec * USEC_PER_SEC) +
  367. b->timestamp.tv_usec);
  368. msm_vidc_set_auto_framerate(inst, timestamp_us);
  369. }
  370. inst->last_qbuf_time_ns = ktime_get_ns();
  371. rc = vb2_qbuf(q, mdev, b);
  372. if (rc)
  373. i_vpr_e(inst, "%s: failed with %d\n", __func__, rc);
  374. exit:
  375. return rc;
  376. }
  377. EXPORT_SYMBOL(msm_vidc_qbuf);
  378. int msm_vidc_dqbuf(void *instance, struct v4l2_buffer *b)
  379. {
  380. int rc = 0;
  381. struct msm_vidc_inst *inst = instance;
  382. struct vb2_queue *q;
  383. if (!inst || !b || !valid_v4l2_buffer(b, inst)) {
  384. d_vpr_e("%s: invalid params %pK %pK\n", __func__, inst, b);
  385. return -EINVAL;
  386. }
  387. q = msm_vidc_get_vb2q(inst, b->type, __func__);
  388. if (!q) {
  389. rc = -EINVAL;
  390. goto exit;
  391. }
  392. rc = vb2_dqbuf(q, b, true);
  393. if (rc == -EAGAIN) {
  394. goto exit;
  395. } else if (rc) {
  396. i_vpr_l(inst, "%s: failed with %d\n", __func__, rc);
  397. goto exit;
  398. }
  399. exit:
  400. return rc;
  401. }
  402. EXPORT_SYMBOL(msm_vidc_dqbuf);
  403. int msm_vidc_streamon(void *instance, enum v4l2_buf_type type)
  404. {
  405. int rc = 0;
  406. struct msm_vidc_inst *inst = instance;
  407. int port;
  408. if (!inst) {
  409. d_vpr_e("%s: invalid params\n", __func__);
  410. return -EINVAL;
  411. }
  412. if (!msm_vidc_allow_streamon(inst, type)) {
  413. rc = -EBUSY;
  414. goto exit;
  415. }
  416. rc = msm_vidc_state_change_streamon(inst, type);
  417. if (rc)
  418. goto exit;
  419. port = v4l2_type_to_driver_port(inst, type, __func__);
  420. if (port < 0) {
  421. rc = -EINVAL;
  422. goto exit;
  423. }
  424. rc = vb2_streamon(&inst->vb2q[port], type);
  425. if (rc) {
  426. i_vpr_e(inst, "%s: vb2_streamon(%d) failed, %d\n",
  427. __func__, type, rc);
  428. msm_vidc_change_inst_state(inst, MSM_VIDC_ERROR, __func__);
  429. goto exit;
  430. }
  431. exit:
  432. return rc;
  433. }
  434. EXPORT_SYMBOL(msm_vidc_streamon);
  435. int msm_vidc_streamoff(void *instance, enum v4l2_buf_type type)
  436. {
  437. int rc = 0;
  438. struct msm_vidc_inst *inst = instance;
  439. int port;
  440. enum msm_vidc_allow allow;
  441. if (!inst) {
  442. d_vpr_e("%s: invalid params\n", __func__);
  443. return -EINVAL;
  444. }
  445. allow = msm_vidc_allow_streamoff(inst, type);
  446. if (allow == MSM_VIDC_DISALLOW) {
  447. rc = -EBUSY;
  448. goto exit;
  449. } else if (allow == MSM_VIDC_IGNORE) {
  450. goto exit;
  451. } else if (allow != MSM_VIDC_ALLOW) {
  452. rc = -EINVAL;
  453. goto exit;
  454. }
  455. rc = msm_vidc_state_change_streamoff(inst, type);
  456. if (rc)
  457. goto exit;
  458. port = v4l2_type_to_driver_port(inst, type, __func__);
  459. if (port < 0) {
  460. rc = -EINVAL;
  461. goto exit;
  462. }
  463. rc = vb2_streamoff(&inst->vb2q[port], type);
  464. if (rc) {
  465. i_vpr_e(inst, "%s: vb2_streamoff(%d) failed, %d\n",
  466. __func__, type, rc);
  467. msm_vidc_change_inst_state(inst, MSM_VIDC_ERROR, __func__);
  468. goto exit;
  469. }
  470. exit:
  471. return rc;
  472. }
  473. EXPORT_SYMBOL(msm_vidc_streamoff);
  474. int msm_vidc_try_cmd(void *instance, union msm_v4l2_cmd *cmd)
  475. {
  476. int rc = 0;
  477. struct msm_vidc_inst *inst = instance;
  478. struct v4l2_decoder_cmd *dec = NULL;
  479. struct v4l2_encoder_cmd *enc = NULL;
  480. if (is_decode_session(inst)) {
  481. dec = (struct v4l2_decoder_cmd *)cmd;
  482. i_vpr_h(inst, "%s: cmd %d\n", __func__, dec->cmd);
  483. if (dec->cmd != V4L2_DEC_CMD_STOP && dec->cmd != V4L2_DEC_CMD_START)
  484. return -EINVAL;
  485. dec->flags = 0;
  486. if (dec->cmd == V4L2_DEC_CMD_STOP) {
  487. dec->stop.pts = 0;
  488. } else if (dec->cmd == V4L2_DEC_CMD_START) {
  489. dec->start.speed = 0;
  490. dec->start.format = V4L2_DEC_START_FMT_NONE;
  491. }
  492. } else if (is_encode_session(inst)) {
  493. enc = (struct v4l2_encoder_cmd *)cmd;
  494. i_vpr_h(inst, "%s: cmd %d\n", __func__, enc->cmd);
  495. if (enc->cmd != V4L2_ENC_CMD_STOP && enc->cmd != V4L2_ENC_CMD_START)
  496. return -EINVAL;
  497. enc->flags = 0;
  498. }
  499. return rc;
  500. }
  501. EXPORT_SYMBOL(msm_vidc_try_cmd);
  502. int msm_vidc_cmd(void *instance, union msm_v4l2_cmd *cmd)
  503. {
  504. int rc = 0;
  505. struct msm_vidc_inst *inst = instance;
  506. struct v4l2_decoder_cmd *dec = NULL;
  507. struct v4l2_encoder_cmd *enc = NULL;
  508. if (is_decode_session(inst)) {
  509. dec = (struct v4l2_decoder_cmd *)cmd;
  510. rc = msm_vdec_process_cmd(inst, dec->cmd);
  511. } else if (is_encode_session(inst)) {
  512. enc = (struct v4l2_encoder_cmd *)cmd;
  513. rc = msm_venc_process_cmd(inst, enc->cmd);
  514. }
  515. if (rc)
  516. return rc;
  517. return 0;
  518. }
  519. EXPORT_SYMBOL(msm_vidc_cmd);
  520. int msm_vidc_enum_framesizes(void *instance, struct v4l2_frmsizeenum *fsize)
  521. {
  522. struct msm_vidc_inst *inst = instance;
  523. struct msm_vidc_inst_capability *capability;
  524. enum msm_vidc_colorformat_type colorfmt;
  525. enum msm_vidc_codec_type codec;
  526. if (!inst || !fsize) {
  527. d_vpr_e("%s: invalid params: %pK %pK\n",
  528. __func__, inst, fsize);
  529. return -EINVAL;
  530. }
  531. if (!inst->capabilities) {
  532. i_vpr_e(inst, "%s: capabilities not available\n", __func__);
  533. return -EINVAL;
  534. }
  535. capability = inst->capabilities;
  536. /* only index 0 allowed as per v4l2 spec */
  537. if (fsize->index)
  538. return -EINVAL;
  539. /* validate pixel format */
  540. codec = v4l2_codec_to_driver(fsize->pixel_format, __func__);
  541. if (!codec) {
  542. colorfmt = v4l2_colorformat_to_driver(fsize->pixel_format, __func__);
  543. if (colorfmt == MSM_VIDC_FMT_NONE) {
  544. i_vpr_e(inst, "%s: unsupported pix fmt %#x\n", __func__, fsize->pixel_format);
  545. return -EINVAL;
  546. }
  547. }
  548. fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
  549. fsize->stepwise.min_width = capability->cap[FRAME_WIDTH].min;
  550. fsize->stepwise.max_width = capability->cap[FRAME_WIDTH].max;
  551. fsize->stepwise.step_width =
  552. capability->cap[FRAME_WIDTH].step_or_mask;
  553. fsize->stepwise.min_height = capability->cap[FRAME_HEIGHT].min;
  554. fsize->stepwise.max_height = capability->cap[FRAME_HEIGHT].max;
  555. fsize->stepwise.step_height =
  556. capability->cap[FRAME_HEIGHT].step_or_mask;
  557. return 0;
  558. }
  559. EXPORT_SYMBOL(msm_vidc_enum_framesizes);
  560. int msm_vidc_enum_frameintervals(void *instance, struct v4l2_frmivalenum *fival)
  561. {
  562. struct msm_vidc_inst *inst = instance;
  563. struct msm_vidc_core *core;
  564. struct msm_vidc_inst_capability *capability;
  565. enum msm_vidc_colorformat_type colorfmt;
  566. u32 fps, mbpf;
  567. if (!inst || !fival) {
  568. d_vpr_e("%s: invalid params: %pK %pK\n",
  569. __func__, inst, fival);
  570. return -EINVAL;
  571. }
  572. if (is_decode_session(inst)) {
  573. i_vpr_e(inst, "%s: not supported by decoder\n", __func__);
  574. return -ENOTTY;
  575. }
  576. core = inst->core;
  577. if (!inst->capabilities || !core->capabilities) {
  578. i_vpr_e(inst, "%s: capabilities not available\n", __func__);
  579. return -EINVAL;
  580. }
  581. capability = inst->capabilities;
  582. /* only index 0 allowed as per v4l2 spec */
  583. if (fival->index)
  584. return -EINVAL;
  585. /* validate pixel format */
  586. colorfmt = v4l2_colorformat_to_driver(fival->pixel_format, __func__);
  587. if (colorfmt == MSM_VIDC_FMT_NONE) {
  588. i_vpr_e(inst, "%s: unsupported pix fmt %#x\n", __func__, fival->pixel_format);
  589. return -EINVAL;
  590. }
  591. /* validate resolution */
  592. if (fival->width > capability->cap[FRAME_WIDTH].max ||
  593. fival->width < capability->cap[FRAME_WIDTH].min ||
  594. fival->height > capability->cap[FRAME_HEIGHT].max ||
  595. fival->height < capability->cap[FRAME_HEIGHT].min) {
  596. i_vpr_e(inst, "%s: unsupported resolution %u x %u\n", __func__,
  597. fival->width, fival->height);
  598. return -EINVAL;
  599. }
  600. /* calculate max supported fps for a given resolution */
  601. mbpf = NUM_MBS_PER_FRAME(fival->height, fival->width);
  602. fps = core->capabilities[MAX_MBPS].value / mbpf;
  603. fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
  604. fival->stepwise.min.numerator = 1;
  605. fival->stepwise.min.denominator =
  606. min_t(u32, fps, capability->cap[FRAME_RATE].max);
  607. fival->stepwise.max.numerator = 1;
  608. fival->stepwise.max.denominator = 1;
  609. fival->stepwise.step.numerator = 1;
  610. fival->stepwise.step.denominator = capability->cap[FRAME_RATE].max;
  611. return 0;
  612. }
  613. EXPORT_SYMBOL(msm_vidc_enum_frameintervals);
  614. int msm_vidc_subscribe_event(void *instance,
  615. const struct v4l2_event_subscription *sub)
  616. {
  617. int rc = 0;
  618. struct msm_vidc_inst *inst = (struct msm_vidc_inst *)instance;
  619. if (!inst || !sub) {
  620. d_vpr_e("%s: invalid params\n", __func__);
  621. return -EINVAL;
  622. }
  623. i_vpr_h(inst, "%s: type %d id %d\n", __func__, sub->type, sub->id);
  624. rc = v4l2_event_subscribe(&inst->event_handler,
  625. sub, MAX_EVENTS, NULL);
  626. if (rc)
  627. i_vpr_e(inst, "%s: fialed, type %d id %d\n",
  628. __func__, sub->type, sub->id);
  629. return rc;
  630. }
  631. EXPORT_SYMBOL(msm_vidc_subscribe_event);
  632. int msm_vidc_unsubscribe_event(void *instance,
  633. const struct v4l2_event_subscription *sub)
  634. {
  635. int rc = 0;
  636. struct msm_vidc_inst *inst = (struct msm_vidc_inst *)instance;
  637. if (!inst || !sub) {
  638. d_vpr_e("%s: invalid params\n", __func__);
  639. return -EINVAL;
  640. }
  641. i_vpr_h(inst, "%s: type %d id %d\n", __func__, sub->type, sub->id);
  642. rc = v4l2_event_unsubscribe(&inst->event_handler, sub);
  643. if (rc)
  644. i_vpr_e(inst, "%s: fialed, type %d id %d\n",
  645. __func__, sub->type, sub->id);
  646. return rc;
  647. }
  648. EXPORT_SYMBOL(msm_vidc_unsubscribe_event);
  649. int msm_vidc_dqevent(void *instance, struct v4l2_event *event)
  650. {
  651. int rc = 0;
  652. struct msm_vidc_inst *inst = (struct msm_vidc_inst *)instance;
  653. if (!inst || !event) {
  654. d_vpr_e("%s: invalid params\n", __func__);
  655. return -EINVAL;
  656. }
  657. rc = v4l2_event_dequeue(&inst->event_handler, event, false);
  658. if (rc)
  659. i_vpr_e(inst, "%s: fialed\n", __func__);
  660. return rc;
  661. }
  662. EXPORT_SYMBOL(msm_vidc_dqevent);
  663. void *msm_vidc_open(void *vidc_core, u32 session_type)
  664. {
  665. int rc = 0;
  666. struct msm_vidc_inst *inst;
  667. struct msm_vidc_core *core;
  668. int i = 0;
  669. d_vpr_h("%s()\n", __func__);
  670. core = vidc_core;
  671. if (!core) {
  672. d_vpr_e("%s: invalid params\n", __func__);
  673. return NULL;
  674. }
  675. if (session_type != MSM_VIDC_DECODER &&
  676. session_type != MSM_VIDC_ENCODER) {
  677. d_vpr_e("%s: invalid session_type %d\n",
  678. __func__, session_type);
  679. return NULL;
  680. }
  681. rc = msm_vidc_core_init(core);
  682. if (rc)
  683. return NULL;
  684. inst = kzalloc(sizeof(*inst), GFP_KERNEL);
  685. if (!inst) {
  686. d_vpr_e("%s: failed to allocate inst memory\n", __func__);
  687. return NULL;
  688. }
  689. inst->core = core;
  690. inst->domain = session_type;
  691. inst->session_id = hash32_ptr(inst);
  692. inst->state = MSM_VIDC_OPEN;
  693. inst->active = true;
  694. inst->request = false;
  695. inst->ipsc_properties_set = false;
  696. inst->opsc_properties_set = false;
  697. inst->has_bframe = false;
  698. inst->auto_framerate = DEFAULT_FPS << 16;
  699. kref_init(&inst->kref);
  700. mutex_init(&inst->lock);
  701. msm_vidc_update_debug_str(inst);
  702. i_vpr_h(inst, "Opening video instance: %d\n", session_type);
  703. rc = msm_memory_pools_init(inst);
  704. if (rc) {
  705. i_vpr_e(inst, "%s: failed to init pool buffers\n", __func__);
  706. kfree(inst);
  707. return NULL;
  708. }
  709. INIT_LIST_HEAD(&inst->response_works);
  710. INIT_LIST_HEAD(&inst->timestamps.list);
  711. INIT_LIST_HEAD(&inst->buffers.input.list);
  712. INIT_LIST_HEAD(&inst->buffers.input_meta.list);
  713. INIT_LIST_HEAD(&inst->buffers.output.list);
  714. INIT_LIST_HEAD(&inst->buffers.output_meta.list);
  715. INIT_LIST_HEAD(&inst->buffers.read_only.list);
  716. INIT_LIST_HEAD(&inst->buffers.release.list);
  717. INIT_LIST_HEAD(&inst->buffers.bin.list);
  718. INIT_LIST_HEAD(&inst->buffers.arp.list);
  719. INIT_LIST_HEAD(&inst->buffers.comv.list);
  720. INIT_LIST_HEAD(&inst->buffers.non_comv.list);
  721. INIT_LIST_HEAD(&inst->buffers.line.list);
  722. INIT_LIST_HEAD(&inst->buffers.dpb.list);
  723. INIT_LIST_HEAD(&inst->buffers.persist.list);
  724. INIT_LIST_HEAD(&inst->buffers.vpss.list);
  725. INIT_LIST_HEAD(&inst->allocations.bin.list);
  726. INIT_LIST_HEAD(&inst->allocations.arp.list);
  727. INIT_LIST_HEAD(&inst->allocations.comv.list);
  728. INIT_LIST_HEAD(&inst->allocations.non_comv.list);
  729. INIT_LIST_HEAD(&inst->allocations.line.list);
  730. INIT_LIST_HEAD(&inst->allocations.dpb.list);
  731. INIT_LIST_HEAD(&inst->allocations.persist.list);
  732. INIT_LIST_HEAD(&inst->allocations.vpss.list);
  733. INIT_LIST_HEAD(&inst->mappings.input.list);
  734. INIT_LIST_HEAD(&inst->mappings.input_meta.list);
  735. INIT_LIST_HEAD(&inst->mappings.output.list);
  736. INIT_LIST_HEAD(&inst->mappings.output_meta.list);
  737. INIT_LIST_HEAD(&inst->mappings.bin.list);
  738. INIT_LIST_HEAD(&inst->mappings.arp.list);
  739. INIT_LIST_HEAD(&inst->mappings.comv.list);
  740. INIT_LIST_HEAD(&inst->mappings.non_comv.list);
  741. INIT_LIST_HEAD(&inst->mappings.line.list);
  742. INIT_LIST_HEAD(&inst->mappings.dpb.list);
  743. INIT_LIST_HEAD(&inst->mappings.persist.list);
  744. INIT_LIST_HEAD(&inst->mappings.vpss.list);
  745. INIT_LIST_HEAD(&inst->children.list);
  746. INIT_LIST_HEAD(&inst->firmware.list);
  747. INIT_LIST_HEAD(&inst->enc_input_crs);
  748. INIT_LIST_HEAD(&inst->dmabuf_tracker);
  749. for (i = 0; i < MAX_SIGNAL; i++)
  750. init_completion(&inst->completions[i]);
  751. inst->response_workq = create_singlethread_workqueue("response_workq");
  752. if (!inst->response_workq) {
  753. i_vpr_e(inst, "%s: create input_psc_workq failed\n", __func__);
  754. goto error;
  755. }
  756. INIT_DELAYED_WORK(&inst->response_work, handle_session_response_work_handler);
  757. INIT_DELAYED_WORK(&inst->stats_work, msm_vidc_stats_handler);
  758. INIT_WORK(&inst->stability_work, msm_vidc_stability_handler);
  759. inst->capabilities = kzalloc(sizeof(struct msm_vidc_inst_capability), GFP_KERNEL);
  760. if (!inst->capabilities) {
  761. i_vpr_e(inst,
  762. "%s: inst capability allocation failed\n", __func__);
  763. goto error;
  764. }
  765. if (is_decode_session(inst))
  766. rc = msm_vdec_inst_init(inst);
  767. else if (is_encode_session(inst))
  768. rc = msm_venc_inst_init(inst);
  769. if (rc)
  770. goto error;
  771. rc = msm_vidc_vb2_queue_init(inst);
  772. if (rc)
  773. goto error;
  774. rc = msm_vidc_event_queue_init(inst);
  775. if (rc)
  776. goto error;
  777. rc = msm_vidc_add_session(inst);
  778. if (rc) {
  779. i_vpr_e(inst, "%s: failed to get session id\n", __func__);
  780. goto error;
  781. }
  782. msm_vidc_scale_power(inst, true);
  783. rc = msm_vidc_session_open(inst);
  784. if (rc) {
  785. msm_vidc_core_deinit(core, true);
  786. goto error;
  787. }
  788. inst->debugfs_root =
  789. msm_vidc_debugfs_init_inst(inst, core->debugfs_root);
  790. if (!inst->debugfs_root)
  791. i_vpr_h(inst, "%s: debugfs not available\n", __func__);
  792. return inst;
  793. error:
  794. msm_vidc_close(inst);
  795. return NULL;
  796. }
  797. EXPORT_SYMBOL(msm_vidc_open);
  798. int msm_vidc_close(void *instance)
  799. {
  800. int rc = 0;
  801. struct msm_vidc_inst *inst = instance;
  802. struct msm_vidc_core *core;
  803. if (!inst) {
  804. d_vpr_e("%s: invalid params\n", __func__);
  805. return -EINVAL;
  806. }
  807. core = inst->core;
  808. i_vpr_h(inst, "%s()\n", __func__);
  809. inst_lock(inst, __func__);
  810. /* print final stats */
  811. msm_vidc_print_stats(inst);
  812. msm_vidc_session_close(inst);
  813. msm_vidc_remove_session(inst);
  814. msm_vidc_destroy_buffers(inst);
  815. inst_unlock(inst, __func__);
  816. cancel_response_work_sync(inst);
  817. cancel_stability_work_sync(inst);
  818. cancel_stats_work_sync(inst);
  819. msm_vidc_show_stats(inst);
  820. put_inst(inst);
  821. msm_vidc_schedule_core_deinit(core);
  822. return rc;
  823. }
  824. EXPORT_SYMBOL(msm_vidc_close);