delta-v4l2.c 49 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) STMicroelectronics SA 2015
  4. * Authors: Hugues Fruchet <hugues.fruchet@st.com>
  5. * Jean-Christophe Trotin <jean-christophe.trotin@st.com>
  6. * for STMicroelectronics.
  7. */
  8. #include <linux/clk.h>
  9. #include <linux/module.h>
  10. #include <linux/platform_device.h>
  11. #include <linux/pm_runtime.h>
  12. #include <linux/slab.h>
  13. #include <media/v4l2-ioctl.h>
  14. #include <media/v4l2-event.h>
  15. #include <media/videobuf2-dma-contig.h>
  16. #include "delta.h"
  17. #include "delta-debug.h"
  18. #include "delta-ipc.h"
  19. #define DELTA_NAME "st-delta"
  20. #define DELTA_PREFIX "[---:----]"
  21. #define to_ctx(__fh) container_of(__fh, struct delta_ctx, fh)
  22. #define to_au(__vbuf) container_of(__vbuf, struct delta_au, vbuf)
  23. #define to_frame(__vbuf) container_of(__vbuf, struct delta_frame, vbuf)
  24. #define call_dec_op(dec, op, args...)\
  25. ((dec && (dec)->op) ? (dec)->op(args) : 0)
  26. /* registry of available decoders */
  27. static const struct delta_dec *delta_decoders[] = {
  28. #ifdef CONFIG_VIDEO_STI_DELTA_MJPEG
  29. &mjpegdec,
  30. #endif
  31. };
  32. static inline int frame_size(u32 w, u32 h, u32 fmt)
  33. {
  34. switch (fmt) {
  35. case V4L2_PIX_FMT_NV12:
  36. return (w * h * 3) / 2;
  37. default:
  38. return 0;
  39. }
  40. }
  41. static inline int frame_stride(u32 w, u32 fmt)
  42. {
  43. switch (fmt) {
  44. case V4L2_PIX_FMT_NV12:
  45. return w;
  46. default:
  47. return 0;
  48. }
  49. }
  50. static void dump_au(struct delta_ctx *ctx, struct delta_au *au)
  51. {
  52. struct delta_dev *delta = ctx->dev;
  53. u32 size = 10; /* dump first & last 10 bytes */
  54. u8 *data = (u8 *)(au->vaddr);
  55. if (au->size <= (size * 2))
  56. dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph\n",
  57. ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,
  58. au->size, data);
  59. else
  60. dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph..%*ph\n",
  61. ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,
  62. size, data, size, data + au->size - size);
  63. }
  64. static void dump_frame(struct delta_ctx *ctx, struct delta_frame *frame)
  65. {
  66. struct delta_dev *delta = ctx->dev;
  67. u32 size = 10; /* dump first 10 bytes */
  68. u8 *data = (u8 *)(frame->vaddr);
  69. dev_dbg(delta->dev, "%s dump frame[%d] dts=%lld type=%s field=%s data=%*ph\n",
  70. ctx->name, frame->index, frame->dts,
  71. frame_type_str(frame->flags),
  72. frame_field_str(frame->field),
  73. size, data);
  74. }
  75. static void delta_au_done(struct delta_ctx *ctx, struct delta_au *au, int err)
  76. {
  77. struct vb2_v4l2_buffer *vbuf;
  78. vbuf = &au->vbuf;
  79. vbuf->sequence = ctx->au_num++;
  80. v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
  81. }
  82. static void delta_frame_done(struct delta_ctx *ctx, struct delta_frame *frame,
  83. int err)
  84. {
  85. struct vb2_v4l2_buffer *vbuf;
  86. dump_frame(ctx, frame);
  87. /* decoded frame is now output to user */
  88. frame->state |= DELTA_FRAME_OUT;
  89. vbuf = &frame->vbuf;
  90. vbuf->sequence = ctx->frame_num++;
  91. v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
  92. if (frame->info.size) /* ignore EOS */
  93. ctx->output_frames++;
  94. }
  95. static void requeue_free_frames(struct delta_ctx *ctx)
  96. {
  97. struct vb2_v4l2_buffer *vbuf;
  98. struct delta_frame *frame;
  99. unsigned int i;
  100. /* requeue all free frames */
  101. for (i = 0; i < ctx->nb_of_frames; i++) {
  102. frame = ctx->frames[i];
  103. if (frame->state == DELTA_FRAME_FREE) {
  104. vbuf = &frame->vbuf;
  105. v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
  106. frame->state = DELTA_FRAME_M2M;
  107. }
  108. }
  109. }
  110. static int delta_recycle(struct delta_ctx *ctx, struct delta_frame *frame)
  111. {
  112. const struct delta_dec *dec = ctx->dec;
  113. /* recycle frame on decoder side */
  114. call_dec_op(dec, recycle, ctx, frame);
  115. /* this frame is no more output */
  116. frame->state &= ~DELTA_FRAME_OUT;
  117. /* requeue free frame */
  118. if (frame->state == DELTA_FRAME_FREE) {
  119. struct vb2_v4l2_buffer *vbuf = &frame->vbuf;
  120. v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
  121. frame->state = DELTA_FRAME_M2M;
  122. }
  123. /* reset other frame fields */
  124. frame->flags = 0;
  125. frame->dts = 0;
  126. return 0;
  127. }
  128. static void delta_push_dts(struct delta_ctx *ctx, u64 val)
  129. {
  130. struct delta_dts *dts;
  131. dts = kzalloc(sizeof(*dts), GFP_KERNEL);
  132. if (!dts)
  133. return;
  134. INIT_LIST_HEAD(&dts->list);
  135. /*
  136. * protected by global lock acquired
  137. * by V4L2 when calling delta_vb2_au_queue
  138. */
  139. dts->val = val;
  140. list_add_tail(&dts->list, &ctx->dts);
  141. }
  142. static void delta_pop_dts(struct delta_ctx *ctx, u64 *val)
  143. {
  144. struct delta_dev *delta = ctx->dev;
  145. struct delta_dts *dts;
  146. /*
  147. * protected by global lock acquired
  148. * by V4L2 when calling delta_vb2_au_queue
  149. */
  150. if (list_empty(&ctx->dts)) {
  151. dev_warn(delta->dev, "%s no dts to pop ... output dts = 0\n",
  152. ctx->name);
  153. *val = 0;
  154. return;
  155. }
  156. dts = list_first_entry(&ctx->dts, struct delta_dts, list);
  157. list_del(&dts->list);
  158. *val = dts->val;
  159. kfree(dts);
  160. }
  161. static void delta_flush_dts(struct delta_ctx *ctx)
  162. {
  163. struct delta_dts *dts;
  164. struct delta_dts *next;
  165. /*
  166. * protected by global lock acquired
  167. * by V4L2 when calling delta_vb2_au_queue
  168. */
  169. /* free all pending dts */
  170. list_for_each_entry_safe(dts, next, &ctx->dts, list)
  171. kfree(dts);
  172. /* reset list */
  173. INIT_LIST_HEAD(&ctx->dts);
  174. }
  175. static inline int frame_alignment(u32 fmt)
  176. {
  177. switch (fmt) {
  178. case V4L2_PIX_FMT_NV12:
  179. case V4L2_PIX_FMT_NV21:
  180. /* multiple of 2 */
  181. return 2;
  182. default:
  183. return 1;
  184. }
  185. }
  186. static inline int estimated_au_size(u32 w, u32 h)
  187. {
  188. /*
  189. * for a MJPEG stream encoded from YUV422 pixel format,
  190. * assuming a compression ratio of 2, the maximum size
  191. * of an access unit is (width x height x 2) / 2,
  192. * so (width x height)
  193. */
  194. return (w * h);
  195. }
  196. static void set_default_params(struct delta_ctx *ctx)
  197. {
  198. struct delta_frameinfo *frameinfo = &ctx->frameinfo;
  199. struct delta_streaminfo *streaminfo = &ctx->streaminfo;
  200. memset(frameinfo, 0, sizeof(*frameinfo));
  201. frameinfo->pixelformat = V4L2_PIX_FMT_NV12;
  202. frameinfo->width = DELTA_DEFAULT_WIDTH;
  203. frameinfo->height = DELTA_DEFAULT_HEIGHT;
  204. frameinfo->aligned_width = ALIGN(frameinfo->width,
  205. DELTA_WIDTH_ALIGNMENT);
  206. frameinfo->aligned_height = ALIGN(frameinfo->height,
  207. DELTA_HEIGHT_ALIGNMENT);
  208. frameinfo->size = frame_size(frameinfo->aligned_width,
  209. frameinfo->aligned_height,
  210. frameinfo->pixelformat);
  211. frameinfo->field = V4L2_FIELD_NONE;
  212. frameinfo->colorspace = V4L2_COLORSPACE_REC709;
  213. frameinfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;
  214. frameinfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
  215. frameinfo->quantization = V4L2_QUANTIZATION_DEFAULT;
  216. memset(streaminfo, 0, sizeof(*streaminfo));
  217. streaminfo->streamformat = DELTA_DEFAULT_STREAMFORMAT;
  218. streaminfo->width = DELTA_DEFAULT_WIDTH;
  219. streaminfo->height = DELTA_DEFAULT_HEIGHT;
  220. streaminfo->field = V4L2_FIELD_NONE;
  221. streaminfo->colorspace = V4L2_COLORSPACE_REC709;
  222. streaminfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;
  223. streaminfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
  224. streaminfo->quantization = V4L2_QUANTIZATION_DEFAULT;
  225. ctx->max_au_size = estimated_au_size(streaminfo->width,
  226. streaminfo->height);
  227. }
  228. static const struct delta_dec *delta_find_decoder(struct delta_ctx *ctx,
  229. u32 streamformat,
  230. u32 pixelformat)
  231. {
  232. struct delta_dev *delta = ctx->dev;
  233. const struct delta_dec *dec;
  234. unsigned int i;
  235. for (i = 0; i < delta->nb_of_decoders; i++) {
  236. dec = delta->decoders[i];
  237. if ((dec->pixelformat == pixelformat) &&
  238. (dec->streamformat == streamformat))
  239. return dec;
  240. }
  241. return NULL;
  242. }
  243. static void register_format(u32 format, u32 formats[], u32 *nb_of_formats)
  244. {
  245. u32 i;
  246. for (i = 0; i < *nb_of_formats; i++) {
  247. if (format == formats[i])
  248. return;
  249. }
  250. formats[(*nb_of_formats)++] = format;
  251. }
  252. static void register_formats(struct delta_dev *delta)
  253. {
  254. unsigned int i;
  255. for (i = 0; i < delta->nb_of_decoders; i++) {
  256. register_format(delta->decoders[i]->pixelformat,
  257. delta->pixelformats,
  258. &delta->nb_of_pixelformats);
  259. register_format(delta->decoders[i]->streamformat,
  260. delta->streamformats,
  261. &delta->nb_of_streamformats);
  262. }
  263. }
  264. static void register_decoders(struct delta_dev *delta)
  265. {
  266. unsigned int i;
  267. for (i = 0; i < ARRAY_SIZE(delta_decoders); i++) {
  268. if (delta->nb_of_decoders >= DELTA_MAX_DECODERS) {
  269. dev_dbg(delta->dev,
  270. "%s failed to register %s decoder (%d maximum reached)\n",
  271. DELTA_PREFIX, delta_decoders[i]->name,
  272. DELTA_MAX_DECODERS);
  273. return;
  274. }
  275. delta->decoders[delta->nb_of_decoders++] = delta_decoders[i];
  276. dev_info(delta->dev, "%s %s decoder registered\n",
  277. DELTA_PREFIX, delta_decoders[i]->name);
  278. }
  279. }
  280. static int delta_open_decoder(struct delta_ctx *ctx, u32 streamformat,
  281. u32 pixelformat, const struct delta_dec **pdec)
  282. {
  283. struct delta_dev *delta = ctx->dev;
  284. const struct delta_dec *dec;
  285. int ret;
  286. dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);
  287. if (!dec) {
  288. dev_err(delta->dev, "%s no decoder found matching %4.4s => %4.4s\n",
  289. ctx->name, (char *)&streamformat, (char *)&pixelformat);
  290. return -EINVAL;
  291. }
  292. dev_dbg(delta->dev, "%s one decoder matching %4.4s => %4.4s\n",
  293. ctx->name, (char *)&streamformat, (char *)&pixelformat);
  294. /* update instance name */
  295. snprintf(ctx->name, sizeof(ctx->name), "[%3d:%4.4s]",
  296. delta->instance_id, (char *)&streamformat);
  297. /* open decoder instance */
  298. ret = call_dec_op(dec, open, ctx);
  299. if (ret) {
  300. dev_err(delta->dev, "%s failed to open decoder instance (%d)\n",
  301. ctx->name, ret);
  302. return ret;
  303. }
  304. dev_dbg(delta->dev, "%s %s decoder opened\n", ctx->name, dec->name);
  305. *pdec = dec;
  306. return ret;
  307. }
  308. /*
  309. * V4L2 ioctl operations
  310. */
  311. static int delta_querycap(struct file *file, void *priv,
  312. struct v4l2_capability *cap)
  313. {
  314. struct delta_ctx *ctx = to_ctx(file->private_data);
  315. struct delta_dev *delta = ctx->dev;
  316. strlcpy(cap->driver, DELTA_NAME, sizeof(cap->driver));
  317. strlcpy(cap->card, delta->vdev->name, sizeof(cap->card));
  318. snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
  319. delta->pdev->name);
  320. return 0;
  321. }
  322. static int delta_enum_fmt_stream(struct file *file, void *priv,
  323. struct v4l2_fmtdesc *f)
  324. {
  325. struct delta_ctx *ctx = to_ctx(file->private_data);
  326. struct delta_dev *delta = ctx->dev;
  327. if (unlikely(f->index >= delta->nb_of_streamformats))
  328. return -EINVAL;
  329. f->pixelformat = delta->streamformats[f->index];
  330. return 0;
  331. }
  332. static int delta_enum_fmt_frame(struct file *file, void *priv,
  333. struct v4l2_fmtdesc *f)
  334. {
  335. struct delta_ctx *ctx = to_ctx(file->private_data);
  336. struct delta_dev *delta = ctx->dev;
  337. if (unlikely(f->index >= delta->nb_of_pixelformats))
  338. return -EINVAL;
  339. f->pixelformat = delta->pixelformats[f->index];
  340. return 0;
  341. }
  342. static int delta_g_fmt_stream(struct file *file, void *fh,
  343. struct v4l2_format *f)
  344. {
  345. struct delta_ctx *ctx = to_ctx(file->private_data);
  346. struct delta_dev *delta = ctx->dev;
  347. struct v4l2_pix_format *pix = &f->fmt.pix;
  348. struct delta_streaminfo *streaminfo = &ctx->streaminfo;
  349. unsigned char str[100] = "";
  350. if (!(ctx->flags & DELTA_FLAG_STREAMINFO))
  351. dev_dbg(delta->dev,
  352. "%s V4L2 GET_FMT (OUTPUT): no stream information available, default to %s\n",
  353. ctx->name,
  354. delta_streaminfo_str(streaminfo, str, sizeof(str)));
  355. pix->pixelformat = streaminfo->streamformat;
  356. pix->width = streaminfo->width;
  357. pix->height = streaminfo->height;
  358. pix->field = streaminfo->field;
  359. pix->bytesperline = 0;
  360. pix->sizeimage = ctx->max_au_size;
  361. pix->colorspace = streaminfo->colorspace;
  362. pix->xfer_func = streaminfo->xfer_func;
  363. pix->ycbcr_enc = streaminfo->ycbcr_enc;
  364. pix->quantization = streaminfo->quantization;
  365. return 0;
  366. }
  367. static int delta_g_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)
  368. {
  369. struct delta_ctx *ctx = to_ctx(file->private_data);
  370. struct delta_dev *delta = ctx->dev;
  371. struct v4l2_pix_format *pix = &f->fmt.pix;
  372. struct delta_frameinfo *frameinfo = &ctx->frameinfo;
  373. struct delta_streaminfo *streaminfo = &ctx->streaminfo;
  374. unsigned char str[100] = "";
  375. if (!(ctx->flags & DELTA_FLAG_FRAMEINFO))
  376. dev_dbg(delta->dev,
  377. "%s V4L2 GET_FMT (CAPTURE): no frame information available, default to %s\n",
  378. ctx->name,
  379. delta_frameinfo_str(frameinfo, str, sizeof(str)));
  380. pix->pixelformat = frameinfo->pixelformat;
  381. pix->width = frameinfo->aligned_width;
  382. pix->height = frameinfo->aligned_height;
  383. pix->field = frameinfo->field;
  384. pix->bytesperline = frame_stride(frameinfo->aligned_width,
  385. frameinfo->pixelformat);
  386. pix->sizeimage = frameinfo->size;
  387. if (ctx->flags & DELTA_FLAG_STREAMINFO) {
  388. /* align colorspace & friends on stream ones if any set */
  389. frameinfo->colorspace = streaminfo->colorspace;
  390. frameinfo->xfer_func = streaminfo->xfer_func;
  391. frameinfo->ycbcr_enc = streaminfo->ycbcr_enc;
  392. frameinfo->quantization = streaminfo->quantization;
  393. }
  394. pix->colorspace = frameinfo->colorspace;
  395. pix->xfer_func = frameinfo->xfer_func;
  396. pix->ycbcr_enc = frameinfo->ycbcr_enc;
  397. pix->quantization = frameinfo->quantization;
  398. return 0;
  399. }
  400. static int delta_try_fmt_stream(struct file *file, void *priv,
  401. struct v4l2_format *f)
  402. {
  403. struct delta_ctx *ctx = to_ctx(file->private_data);
  404. struct delta_dev *delta = ctx->dev;
  405. struct v4l2_pix_format *pix = &f->fmt.pix;
  406. u32 streamformat = pix->pixelformat;
  407. const struct delta_dec *dec;
  408. u32 width, height;
  409. u32 au_size;
  410. dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);
  411. if (!dec) {
  412. dev_dbg(delta->dev,
  413. "%s V4L2 TRY_FMT (OUTPUT): unsupported format %4.4s\n",
  414. ctx->name, (char *)&pix->pixelformat);
  415. return -EINVAL;
  416. }
  417. /* adjust width & height */
  418. width = pix->width;
  419. height = pix->height;
  420. v4l_bound_align_image
  421. (&pix->width,
  422. DELTA_MIN_WIDTH,
  423. dec->max_width ? dec->max_width : DELTA_MAX_WIDTH,
  424. 0,
  425. &pix->height,
  426. DELTA_MIN_HEIGHT,
  427. dec->max_height ? dec->max_height : DELTA_MAX_HEIGHT,
  428. 0, 0);
  429. if ((pix->width != width) || (pix->height != height))
  430. dev_dbg(delta->dev,
  431. "%s V4L2 TRY_FMT (OUTPUT): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",
  432. ctx->name, width, height,
  433. pix->width, pix->height);
  434. au_size = estimated_au_size(pix->width, pix->height);
  435. if (pix->sizeimage < au_size) {
  436. dev_dbg(delta->dev,
  437. "%s V4L2 TRY_FMT (OUTPUT): size updated %d -> %d to fit estimated size\n",
  438. ctx->name, pix->sizeimage, au_size);
  439. pix->sizeimage = au_size;
  440. }
  441. pix->bytesperline = 0;
  442. if (pix->field == V4L2_FIELD_ANY)
  443. pix->field = V4L2_FIELD_NONE;
  444. return 0;
  445. }
  446. static int delta_try_fmt_frame(struct file *file, void *priv,
  447. struct v4l2_format *f)
  448. {
  449. struct delta_ctx *ctx = to_ctx(file->private_data);
  450. struct delta_dev *delta = ctx->dev;
  451. struct v4l2_pix_format *pix = &f->fmt.pix;
  452. u32 pixelformat = pix->pixelformat;
  453. const struct delta_dec *dec;
  454. u32 width, height;
  455. dec = delta_find_decoder(ctx, ctx->streaminfo.streamformat,
  456. pixelformat);
  457. if (!dec) {
  458. dev_dbg(delta->dev,
  459. "%s V4L2 TRY_FMT (CAPTURE): unsupported format %4.4s\n",
  460. ctx->name, (char *)&pixelformat);
  461. return -EINVAL;
  462. }
  463. /* adjust width & height */
  464. width = pix->width;
  465. height = pix->height;
  466. v4l_bound_align_image(&pix->width,
  467. DELTA_MIN_WIDTH, DELTA_MAX_WIDTH,
  468. frame_alignment(pixelformat) - 1,
  469. &pix->height,
  470. DELTA_MIN_HEIGHT, DELTA_MAX_HEIGHT,
  471. frame_alignment(pixelformat) - 1, 0);
  472. if ((pix->width != width) || (pix->height != height))
  473. dev_dbg(delta->dev,
  474. "%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",
  475. ctx->name, width, height, pix->width, pix->height);
  476. /* default decoder alignment constraint */
  477. width = ALIGN(pix->width, DELTA_WIDTH_ALIGNMENT);
  478. height = ALIGN(pix->height, DELTA_HEIGHT_ALIGNMENT);
  479. if ((pix->width != width) || (pix->height != height))
  480. dev_dbg(delta->dev,
  481. "%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit decoder alignment\n",
  482. ctx->name, width, height, pix->width, pix->height);
  483. if (!pix->colorspace) {
  484. pix->colorspace = V4L2_COLORSPACE_REC709;
  485. pix->xfer_func = V4L2_XFER_FUNC_DEFAULT;
  486. pix->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
  487. pix->quantization = V4L2_QUANTIZATION_DEFAULT;
  488. }
  489. pix->width = width;
  490. pix->height = height;
  491. pix->bytesperline = frame_stride(pix->width, pixelformat);
  492. pix->sizeimage = frame_size(pix->width, pix->height, pixelformat);
  493. if (pix->field == V4L2_FIELD_ANY)
  494. pix->field = V4L2_FIELD_NONE;
  495. return 0;
  496. }
  497. static int delta_s_fmt_stream(struct file *file, void *fh,
  498. struct v4l2_format *f)
  499. {
  500. struct delta_ctx *ctx = to_ctx(file->private_data);
  501. struct delta_dev *delta = ctx->dev;
  502. struct vb2_queue *vq;
  503. struct v4l2_pix_format *pix = &f->fmt.pix;
  504. int ret;
  505. ret = delta_try_fmt_stream(file, fh, f);
  506. if (ret) {
  507. dev_dbg(delta->dev,
  508. "%s V4L2 S_FMT (OUTPUT): unsupported format %4.4s\n",
  509. ctx->name, (char *)&pix->pixelformat);
  510. return ret;
  511. }
  512. vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
  513. if (vb2_is_streaming(vq)) {
  514. dev_dbg(delta->dev, "%s V4L2 S_FMT (OUTPUT): queue busy\n",
  515. ctx->name);
  516. return -EBUSY;
  517. }
  518. ctx->max_au_size = pix->sizeimage;
  519. ctx->streaminfo.width = pix->width;
  520. ctx->streaminfo.height = pix->height;
  521. ctx->streaminfo.streamformat = pix->pixelformat;
  522. ctx->streaminfo.colorspace = pix->colorspace;
  523. ctx->streaminfo.xfer_func = pix->xfer_func;
  524. ctx->streaminfo.ycbcr_enc = pix->ycbcr_enc;
  525. ctx->streaminfo.quantization = pix->quantization;
  526. ctx->flags |= DELTA_FLAG_STREAMINFO;
  527. return 0;
  528. }
  529. static int delta_s_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)
  530. {
  531. struct delta_ctx *ctx = to_ctx(file->private_data);
  532. struct delta_dev *delta = ctx->dev;
  533. const struct delta_dec *dec = ctx->dec;
  534. struct v4l2_pix_format *pix = &f->fmt.pix;
  535. struct delta_frameinfo frameinfo;
  536. unsigned char str[100] = "";
  537. struct vb2_queue *vq;
  538. int ret;
  539. vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
  540. if (vb2_is_streaming(vq)) {
  541. dev_dbg(delta->dev, "%s V4L2 S_FMT (CAPTURE): queue busy\n",
  542. ctx->name);
  543. return -EBUSY;
  544. }
  545. if (ctx->state < DELTA_STATE_READY) {
  546. /*
  547. * decoder not yet opened and valid stream header not found,
  548. * could not negotiate format with decoder, check at least
  549. * pixel format & negotiate resolution boundaries
  550. * and alignment...
  551. */
  552. ret = delta_try_fmt_frame(file, fh, f);
  553. if (ret) {
  554. dev_dbg(delta->dev,
  555. "%s V4L2 S_FMT (CAPTURE): unsupported format %4.4s\n",
  556. ctx->name, (char *)&pix->pixelformat);
  557. return ret;
  558. }
  559. return 0;
  560. }
  561. /* set frame information to decoder */
  562. memset(&frameinfo, 0, sizeof(frameinfo));
  563. frameinfo.pixelformat = pix->pixelformat;
  564. frameinfo.width = pix->width;
  565. frameinfo.height = pix->height;
  566. frameinfo.aligned_width = pix->width;
  567. frameinfo.aligned_height = pix->height;
  568. frameinfo.size = pix->sizeimage;
  569. frameinfo.field = pix->field;
  570. frameinfo.colorspace = pix->colorspace;
  571. frameinfo.xfer_func = pix->xfer_func;
  572. frameinfo.ycbcr_enc = pix->ycbcr_enc;
  573. frameinfo.quantization = pix->quantization;
  574. ret = call_dec_op(dec, set_frameinfo, ctx, &frameinfo);
  575. if (ret)
  576. return ret;
  577. /* then get what decoder can really do */
  578. ret = call_dec_op(dec, get_frameinfo, ctx, &frameinfo);
  579. if (ret)
  580. return ret;
  581. ctx->flags |= DELTA_FLAG_FRAMEINFO;
  582. ctx->frameinfo = frameinfo;
  583. dev_dbg(delta->dev,
  584. "%s V4L2 SET_FMT (CAPTURE): frameinfo updated to %s\n",
  585. ctx->name,
  586. delta_frameinfo_str(&frameinfo, str, sizeof(str)));
  587. pix->pixelformat = frameinfo.pixelformat;
  588. pix->width = frameinfo.aligned_width;
  589. pix->height = frameinfo.aligned_height;
  590. pix->bytesperline = frame_stride(pix->width, pix->pixelformat);
  591. pix->sizeimage = frameinfo.size;
  592. pix->field = frameinfo.field;
  593. pix->colorspace = frameinfo.colorspace;
  594. pix->xfer_func = frameinfo.xfer_func;
  595. pix->ycbcr_enc = frameinfo.ycbcr_enc;
  596. pix->quantization = frameinfo.quantization;
  597. return 0;
  598. }
  599. static int delta_g_selection(struct file *file, void *fh,
  600. struct v4l2_selection *s)
  601. {
  602. struct delta_ctx *ctx = to_ctx(fh);
  603. struct delta_frameinfo *frameinfo = &ctx->frameinfo;
  604. struct v4l2_rect crop;
  605. if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  606. return -EINVAL;
  607. if ((ctx->flags & DELTA_FLAG_FRAMEINFO) &&
  608. (frameinfo->flags & DELTA_FRAMEINFO_FLAG_CROP)) {
  609. crop = frameinfo->crop;
  610. } else {
  611. /* default to video dimensions */
  612. crop.left = 0;
  613. crop.top = 0;
  614. crop.width = frameinfo->width;
  615. crop.height = frameinfo->height;
  616. }
  617. switch (s->target) {
  618. case V4L2_SEL_TGT_COMPOSE:
  619. case V4L2_SEL_TGT_COMPOSE_DEFAULT:
  620. /* visible area inside video */
  621. s->r = crop;
  622. break;
  623. case V4L2_SEL_TGT_COMPOSE_PADDED:
  624. case V4L2_SEL_TGT_COMPOSE_BOUNDS:
  625. /* up to aligned dimensions */
  626. s->r.left = 0;
  627. s->r.top = 0;
  628. s->r.width = frameinfo->aligned_width;
  629. s->r.height = frameinfo->aligned_height;
  630. break;
  631. default:
  632. return -EINVAL;
  633. }
  634. return 0;
  635. }
  636. static void delta_complete_eos(struct delta_ctx *ctx,
  637. struct delta_frame *frame)
  638. {
  639. struct delta_dev *delta = ctx->dev;
  640. const struct v4l2_event ev = {.type = V4L2_EVENT_EOS};
  641. /*
  642. * Send EOS to user:
  643. * - by returning an empty frame flagged to V4L2_BUF_FLAG_LAST
  644. * - and then send EOS event
  645. */
  646. /* empty frame */
  647. frame->info.size = 0;
  648. /* set the last buffer flag */
  649. frame->flags |= V4L2_BUF_FLAG_LAST;
  650. /* release frame to user */
  651. delta_frame_done(ctx, frame, 0);
  652. /* send EOS event */
  653. v4l2_event_queue_fh(&ctx->fh, &ev);
  654. dev_dbg(delta->dev, "%s EOS completed\n", ctx->name);
  655. }
  656. static int delta_try_decoder_cmd(struct file *file, void *fh,
  657. struct v4l2_decoder_cmd *cmd)
  658. {
  659. if (cmd->cmd != V4L2_DEC_CMD_STOP)
  660. return -EINVAL;
  661. if (cmd->flags & V4L2_DEC_CMD_STOP_TO_BLACK)
  662. return -EINVAL;
  663. if (!(cmd->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) &&
  664. (cmd->stop.pts != 0))
  665. return -EINVAL;
  666. return 0;
  667. }
  668. static int delta_decoder_stop_cmd(struct delta_ctx *ctx, void *fh)
  669. {
  670. const struct delta_dec *dec = ctx->dec;
  671. struct delta_dev *delta = ctx->dev;
  672. struct delta_frame *frame = NULL;
  673. int ret = 0;
  674. dev_dbg(delta->dev, "%s EOS received\n", ctx->name);
  675. if (ctx->state != DELTA_STATE_READY)
  676. return 0;
  677. /* drain the decoder */
  678. call_dec_op(dec, drain, ctx);
  679. /* release to user drained frames */
  680. while (1) {
  681. frame = NULL;
  682. ret = call_dec_op(dec, get_frame, ctx, &frame);
  683. if (ret == -ENODATA) {
  684. /* no more decoded frames */
  685. break;
  686. }
  687. if (frame) {
  688. dev_dbg(delta->dev, "%s drain frame[%d]\n",
  689. ctx->name, frame->index);
  690. /* pop timestamp and mark frame with it */
  691. delta_pop_dts(ctx, &frame->dts);
  692. /* release decoded frame to user */
  693. delta_frame_done(ctx, frame, 0);
  694. }
  695. }
  696. /* try to complete EOS */
  697. ret = delta_get_free_frame(ctx, &frame);
  698. if (ret)
  699. goto delay_eos;
  700. /* new frame available, EOS can now be completed */
  701. delta_complete_eos(ctx, frame);
  702. ctx->state = DELTA_STATE_EOS;
  703. return 0;
  704. delay_eos:
  705. /*
  706. * EOS completion from driver is delayed because
  707. * we don't have a free empty frame available.
  708. * EOS completion is so delayed till next frame_queue() call
  709. * to be sure to have a free empty frame available.
  710. */
  711. ctx->state = DELTA_STATE_WF_EOS;
  712. dev_dbg(delta->dev, "%s EOS delayed\n", ctx->name);
  713. return 0;
  714. }
  715. static int delta_decoder_cmd(struct file *file, void *fh,
  716. struct v4l2_decoder_cmd *cmd)
  717. {
  718. struct delta_ctx *ctx = to_ctx(fh);
  719. int ret = 0;
  720. ret = delta_try_decoder_cmd(file, fh, cmd);
  721. if (ret)
  722. return ret;
  723. return delta_decoder_stop_cmd(ctx, fh);
  724. }
  725. static int delta_subscribe_event(struct v4l2_fh *fh,
  726. const struct v4l2_event_subscription *sub)
  727. {
  728. switch (sub->type) {
  729. case V4L2_EVENT_EOS:
  730. return v4l2_event_subscribe(fh, sub, 2, NULL);
  731. default:
  732. return -EINVAL;
  733. }
  734. return 0;
  735. }
  736. /* v4l2 ioctl ops */
  737. static const struct v4l2_ioctl_ops delta_ioctl_ops = {
  738. .vidioc_querycap = delta_querycap,
  739. .vidioc_enum_fmt_vid_cap = delta_enum_fmt_frame,
  740. .vidioc_g_fmt_vid_cap = delta_g_fmt_frame,
  741. .vidioc_try_fmt_vid_cap = delta_try_fmt_frame,
  742. .vidioc_s_fmt_vid_cap = delta_s_fmt_frame,
  743. .vidioc_enum_fmt_vid_out = delta_enum_fmt_stream,
  744. .vidioc_g_fmt_vid_out = delta_g_fmt_stream,
  745. .vidioc_try_fmt_vid_out = delta_try_fmt_stream,
  746. .vidioc_s_fmt_vid_out = delta_s_fmt_stream,
  747. .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
  748. .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
  749. .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
  750. .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
  751. .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
  752. .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
  753. .vidioc_streamon = v4l2_m2m_ioctl_streamon,
  754. .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
  755. .vidioc_g_selection = delta_g_selection,
  756. .vidioc_try_decoder_cmd = delta_try_decoder_cmd,
  757. .vidioc_decoder_cmd = delta_decoder_cmd,
  758. .vidioc_subscribe_event = delta_subscribe_event,
  759. .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
  760. };
  761. /*
  762. * mem-to-mem operations
  763. */
  764. static void delta_run_work(struct work_struct *work)
  765. {
  766. struct delta_ctx *ctx = container_of(work, struct delta_ctx, run_work);
  767. struct delta_dev *delta = ctx->dev;
  768. const struct delta_dec *dec = ctx->dec;
  769. struct delta_au *au;
  770. struct delta_frame *frame = NULL;
  771. int ret = 0;
  772. bool discard = false;
  773. struct vb2_v4l2_buffer *vbuf;
  774. if (!dec) {
  775. dev_err(delta->dev, "%s no decoder opened yet\n", ctx->name);
  776. return;
  777. }
  778. /* protect instance against reentrancy */
  779. mutex_lock(&ctx->lock);
  780. vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
  781. if (!vbuf) {
  782. dev_err(delta->dev, "%s no buffer to decode\n", ctx->name);
  783. mutex_unlock(&ctx->lock);
  784. return;
  785. }
  786. au = to_au(vbuf);
  787. au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);
  788. au->dts = vbuf->vb2_buf.timestamp;
  789. /* dump access unit */
  790. dump_au(ctx, au);
  791. /* enable the hardware */
  792. if (!dec->pm) {
  793. ret = delta_get_sync(ctx);
  794. if (ret)
  795. goto err;
  796. }
  797. /* decode this access unit */
  798. ret = call_dec_op(dec, decode, ctx, au);
  799. /*
  800. * if the (-ENODATA) value is returned, it refers to the interlaced
  801. * stream case for which 2 access units are needed to get 1 frame.
  802. * So, this returned value doesn't mean that the decoding fails, but
  803. * indicates that the timestamp information of the access unit shall
  804. * not be taken into account, and that the V4L2 buffer associated with
  805. * the access unit shall be flagged with V4L2_BUF_FLAG_ERROR to inform
  806. * the user of this situation
  807. */
  808. if (ret == -ENODATA) {
  809. discard = true;
  810. } else if (ret) {
  811. dev_err(delta->dev, "%s decoding failed (%d)\n",
  812. ctx->name, ret);
  813. /* disable the hardware */
  814. if (!dec->pm)
  815. delta_put_autosuspend(ctx);
  816. goto err;
  817. }
  818. /* disable the hardware */
  819. if (!dec->pm)
  820. delta_put_autosuspend(ctx);
  821. /* push au timestamp in FIFO */
  822. if (!discard)
  823. delta_push_dts(ctx, au->dts);
  824. /* get available decoded frames */
  825. while (1) {
  826. ret = call_dec_op(dec, get_frame, ctx, &frame);
  827. if (ret == -ENODATA) {
  828. /* no more decoded frames */
  829. goto out;
  830. }
  831. if (ret) {
  832. dev_err(delta->dev, "%s cannot get decoded frame (%d)\n",
  833. ctx->name, ret);
  834. goto out;
  835. }
  836. if (!frame) {
  837. dev_err(delta->dev,
  838. "%s NULL decoded frame\n",
  839. ctx->name);
  840. ret = -EIO;
  841. goto out;
  842. }
  843. /* pop timestamp and mark frame with it */
  844. delta_pop_dts(ctx, &frame->dts);
  845. /* release decoded frame to user */
  846. delta_frame_done(ctx, frame, 0);
  847. }
  848. out:
  849. requeue_free_frames(ctx);
  850. delta_au_done(ctx, au, (discard ? -ENODATA : 0));
  851. mutex_unlock(&ctx->lock);
  852. v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);
  853. return;
  854. err:
  855. requeue_free_frames(ctx);
  856. delta_au_done(ctx, au, ret);
  857. mutex_unlock(&ctx->lock);
  858. v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);
  859. }
  860. static void delta_device_run(void *priv)
  861. {
  862. struct delta_ctx *ctx = priv;
  863. struct delta_dev *delta = ctx->dev;
  864. queue_work(delta->work_queue, &ctx->run_work);
  865. }
  866. static void delta_job_abort(void *priv)
  867. {
  868. struct delta_ctx *ctx = priv;
  869. struct delta_dev *delta = ctx->dev;
  870. dev_dbg(delta->dev, "%s aborting job\n", ctx->name);
  871. ctx->aborting = true;
  872. }
  873. static int delta_job_ready(void *priv)
  874. {
  875. struct delta_ctx *ctx = priv;
  876. struct delta_dev *delta = ctx->dev;
  877. int src_bufs = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx);
  878. if (!src_bufs) {
  879. dev_dbg(delta->dev, "%s not ready: not enough video buffers.\n",
  880. ctx->name);
  881. return 0;
  882. }
  883. if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) {
  884. dev_dbg(delta->dev, "%s not ready: not enough video capture buffers.\n",
  885. ctx->name);
  886. return 0;
  887. }
  888. if (ctx->aborting) {
  889. dev_dbg(delta->dev, "%s job not ready: aborting\n", ctx->name);
  890. return 0;
  891. }
  892. dev_dbg(delta->dev, "%s job ready\n", ctx->name);
  893. return 1;
  894. }
  895. /* mem-to-mem ops */
  896. static const struct v4l2_m2m_ops delta_m2m_ops = {
  897. .device_run = delta_device_run,
  898. .job_ready = delta_job_ready,
  899. .job_abort = delta_job_abort,
  900. };
  901. /*
  902. * VB2 queue operations
  903. */
  904. static int delta_vb2_au_queue_setup(struct vb2_queue *vq,
  905. unsigned int *num_buffers,
  906. unsigned int *num_planes,
  907. unsigned int sizes[],
  908. struct device *alloc_devs[])
  909. {
  910. struct delta_ctx *ctx = vb2_get_drv_priv(vq);
  911. unsigned int size = ctx->max_au_size;
  912. if (*num_planes)
  913. return sizes[0] < size ? -EINVAL : 0;
  914. *num_planes = 1;
  915. if (*num_buffers < 1)
  916. *num_buffers = 1;
  917. if (*num_buffers > DELTA_MAX_AUS)
  918. *num_buffers = DELTA_MAX_AUS;
  919. sizes[0] = size;
  920. return 0;
  921. }
  922. static int delta_vb2_au_prepare(struct vb2_buffer *vb)
  923. {
  924. struct vb2_queue *q = vb->vb2_queue;
  925. struct delta_ctx *ctx = vb2_get_drv_priv(q);
  926. struct delta_dev *delta = ctx->dev;
  927. struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
  928. struct delta_au *au = to_au(vbuf);
  929. if (!au->prepared) {
  930. /* get memory addresses */
  931. au->vaddr = vb2_plane_vaddr(&au->vbuf.vb2_buf, 0);
  932. au->paddr = vb2_dma_contig_plane_dma_addr
  933. (&au->vbuf.vb2_buf, 0);
  934. au->prepared = true;
  935. dev_dbg(delta->dev, "%s au[%d] prepared; virt=0x%p, phy=0x%pad\n",
  936. ctx->name, vb->index, au->vaddr, &au->paddr);
  937. }
  938. if (vbuf->field == V4L2_FIELD_ANY)
  939. vbuf->field = V4L2_FIELD_NONE;
  940. return 0;
  941. }
  942. static int delta_setup_frame(struct delta_ctx *ctx,
  943. struct delta_frame *frame)
  944. {
  945. struct delta_dev *delta = ctx->dev;
  946. const struct delta_dec *dec = ctx->dec;
  947. if (frame->index >= DELTA_MAX_FRAMES) {
  948. dev_err(delta->dev,
  949. "%s frame index=%d exceeds output frame count (%d)\n",
  950. ctx->name, frame->index, DELTA_MAX_FRAMES);
  951. return -EINVAL;
  952. }
  953. if (ctx->nb_of_frames >= DELTA_MAX_FRAMES) {
  954. dev_err(delta->dev,
  955. "%s number of frames exceeds output frame count (%d > %d)\n",
  956. ctx->name, ctx->nb_of_frames, DELTA_MAX_FRAMES);
  957. return -EINVAL;
  958. }
  959. if (frame->index != ctx->nb_of_frames) {
  960. dev_warn(delta->dev,
  961. "%s frame index discontinuity detected, expected %d, got %d\n",
  962. ctx->name, ctx->nb_of_frames, frame->index);
  963. }
  964. frame->state = DELTA_FRAME_FREE;
  965. ctx->frames[ctx->nb_of_frames] = frame;
  966. ctx->nb_of_frames++;
  967. /* setup frame on decoder side */
  968. return call_dec_op(dec, setup_frame, ctx, frame);
  969. }
  970. /*
  971. * default implementation of get_frameinfo decoder ops
  972. * matching frame information from stream information
  973. * & with default pixel format & default alignment.
  974. */
  975. int delta_get_frameinfo_default(struct delta_ctx *ctx,
  976. struct delta_frameinfo *frameinfo)
  977. {
  978. struct delta_streaminfo *streaminfo = &ctx->streaminfo;
  979. memset(frameinfo, 0, sizeof(*frameinfo));
  980. frameinfo->pixelformat = V4L2_PIX_FMT_NV12;
  981. frameinfo->width = streaminfo->width;
  982. frameinfo->height = streaminfo->height;
  983. frameinfo->aligned_width = ALIGN(streaminfo->width,
  984. DELTA_WIDTH_ALIGNMENT);
  985. frameinfo->aligned_height = ALIGN(streaminfo->height,
  986. DELTA_HEIGHT_ALIGNMENT);
  987. frameinfo->size = frame_size(frameinfo->aligned_width,
  988. frameinfo->aligned_height,
  989. frameinfo->pixelformat);
  990. if (streaminfo->flags & DELTA_STREAMINFO_FLAG_CROP) {
  991. frameinfo->flags |= DELTA_FRAMEINFO_FLAG_CROP;
  992. frameinfo->crop = streaminfo->crop;
  993. }
  994. if (streaminfo->flags & DELTA_STREAMINFO_FLAG_PIXELASPECT) {
  995. frameinfo->flags |= DELTA_FRAMEINFO_FLAG_PIXELASPECT;
  996. frameinfo->pixelaspect = streaminfo->pixelaspect;
  997. }
  998. frameinfo->field = streaminfo->field;
  999. return 0;
  1000. }
  1001. /*
  1002. * default implementation of recycle decoder ops
  1003. * consisting to relax the "decoded" frame state
  1004. */
  1005. int delta_recycle_default(struct delta_ctx *pctx,
  1006. struct delta_frame *frame)
  1007. {
  1008. frame->state &= ~DELTA_FRAME_DEC;
  1009. return 0;
  1010. }
  1011. static void dump_frames_status(struct delta_ctx *ctx)
  1012. {
  1013. struct delta_dev *delta = ctx->dev;
  1014. unsigned int i;
  1015. struct delta_frame *frame;
  1016. unsigned char str[100] = "";
  1017. dev_info(delta->dev,
  1018. "%s dumping frames status...\n", ctx->name);
  1019. for (i = 0; i < ctx->nb_of_frames; i++) {
  1020. frame = ctx->frames[i];
  1021. dev_info(delta->dev,
  1022. "%s frame[%d] %s\n",
  1023. ctx->name, frame->index,
  1024. frame_state_str(frame->state,
  1025. str, sizeof(str)));
  1026. }
  1027. }
  1028. int delta_get_free_frame(struct delta_ctx *ctx,
  1029. struct delta_frame **pframe)
  1030. {
  1031. struct delta_dev *delta = ctx->dev;
  1032. struct vb2_v4l2_buffer *vbuf;
  1033. struct delta_frame *frame;
  1034. *pframe = NULL;
  1035. vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
  1036. if (!vbuf) {
  1037. dev_err(delta->dev, "%s no frame available",
  1038. ctx->name);
  1039. return -EIO;
  1040. }
  1041. frame = to_frame(vbuf);
  1042. frame->state &= ~DELTA_FRAME_M2M;
  1043. if (frame->state != DELTA_FRAME_FREE) {
  1044. dev_err(delta->dev,
  1045. "%s frame[%d] is not free\n",
  1046. ctx->name, frame->index);
  1047. dump_frames_status(ctx);
  1048. return -ENODATA;
  1049. }
  1050. dev_dbg(delta->dev,
  1051. "%s get free frame[%d]\n", ctx->name, frame->index);
  1052. *pframe = frame;
  1053. return 0;
  1054. }
  1055. int delta_get_sync(struct delta_ctx *ctx)
  1056. {
  1057. struct delta_dev *delta = ctx->dev;
  1058. int ret = 0;
  1059. /* enable the hardware */
  1060. ret = pm_runtime_get_sync(delta->dev);
  1061. if (ret < 0) {
  1062. dev_err(delta->dev, "%s pm_runtime_get_sync failed (%d)\n",
  1063. __func__, ret);
  1064. return ret;
  1065. }
  1066. return 0;
  1067. }
  1068. void delta_put_autosuspend(struct delta_ctx *ctx)
  1069. {
  1070. struct delta_dev *delta = ctx->dev;
  1071. pm_runtime_put_autosuspend(delta->dev);
  1072. }
  1073. static void delta_vb2_au_queue(struct vb2_buffer *vb)
  1074. {
  1075. struct vb2_queue *q = vb->vb2_queue;
  1076. struct delta_ctx *ctx = vb2_get_drv_priv(q);
  1077. struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
  1078. v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
  1079. }
  1080. static int delta_vb2_au_start_streaming(struct vb2_queue *q,
  1081. unsigned int count)
  1082. {
  1083. struct delta_ctx *ctx = vb2_get_drv_priv(q);
  1084. struct delta_dev *delta = ctx->dev;
  1085. const struct delta_dec *dec = ctx->dec;
  1086. struct delta_au *au;
  1087. int ret = 0;
  1088. struct vb2_v4l2_buffer *vbuf = NULL;
  1089. struct delta_streaminfo *streaminfo = &ctx->streaminfo;
  1090. struct delta_frameinfo *frameinfo = &ctx->frameinfo;
  1091. unsigned char str1[100] = "";
  1092. unsigned char str2[100] = "";
  1093. if ((ctx->state != DELTA_STATE_WF_FORMAT) &&
  1094. (ctx->state != DELTA_STATE_WF_STREAMINFO))
  1095. return 0;
  1096. if (ctx->state == DELTA_STATE_WF_FORMAT) {
  1097. /* open decoder if not yet done */
  1098. ret = delta_open_decoder(ctx,
  1099. ctx->streaminfo.streamformat,
  1100. ctx->frameinfo.pixelformat, &dec);
  1101. if (ret)
  1102. goto err;
  1103. ctx->dec = dec;
  1104. ctx->state = DELTA_STATE_WF_STREAMINFO;
  1105. }
  1106. /*
  1107. * first buffer should contain stream header,
  1108. * decode it to get the infos related to stream
  1109. * such as width, height, dpb, ...
  1110. */
  1111. vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
  1112. if (!vbuf) {
  1113. dev_err(delta->dev, "%s failed to start streaming, no stream header buffer enqueued\n",
  1114. ctx->name);
  1115. ret = -EINVAL;
  1116. goto err;
  1117. }
  1118. au = to_au(vbuf);
  1119. au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);
  1120. au->dts = vbuf->vb2_buf.timestamp;
  1121. delta_push_dts(ctx, au->dts);
  1122. /* dump access unit */
  1123. dump_au(ctx, au);
  1124. /* decode this access unit */
  1125. ret = call_dec_op(dec, decode, ctx, au);
  1126. if (ret) {
  1127. dev_err(delta->dev, "%s failed to start streaming, header decoding failed (%d)\n",
  1128. ctx->name, ret);
  1129. goto err;
  1130. }
  1131. ret = call_dec_op(dec, get_streaminfo, ctx, streaminfo);
  1132. if (ret) {
  1133. dev_dbg_ratelimited(delta->dev,
  1134. "%s failed to start streaming, valid stream header not yet decoded\n",
  1135. ctx->name);
  1136. goto err;
  1137. }
  1138. ctx->flags |= DELTA_FLAG_STREAMINFO;
  1139. ret = call_dec_op(dec, get_frameinfo, ctx, frameinfo);
  1140. if (ret)
  1141. goto err;
  1142. ctx->flags |= DELTA_FLAG_FRAMEINFO;
  1143. ctx->state = DELTA_STATE_READY;
  1144. dev_dbg(delta->dev, "%s %s => %s\n", ctx->name,
  1145. delta_streaminfo_str(streaminfo, str1, sizeof(str1)),
  1146. delta_frameinfo_str(frameinfo, str2, sizeof(str2)));
  1147. delta_au_done(ctx, au, ret);
  1148. return 0;
  1149. err:
  1150. /*
  1151. * return all buffers to vb2 in QUEUED state.
  1152. * This will give ownership back to userspace
  1153. */
  1154. if (vbuf)
  1155. v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);
  1156. while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
  1157. v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);
  1158. return ret;
  1159. }
  1160. static void delta_vb2_au_stop_streaming(struct vb2_queue *q)
  1161. {
  1162. struct delta_ctx *ctx = vb2_get_drv_priv(q);
  1163. struct vb2_v4l2_buffer *vbuf;
  1164. delta_flush_dts(ctx);
  1165. /* return all buffers to vb2 in ERROR state */
  1166. while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
  1167. v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
  1168. ctx->au_num = 0;
  1169. ctx->aborting = false;
  1170. }
  1171. static int delta_vb2_frame_queue_setup(struct vb2_queue *vq,
  1172. unsigned int *num_buffers,
  1173. unsigned int *num_planes,
  1174. unsigned int sizes[],
  1175. struct device *alloc_devs[])
  1176. {
  1177. struct delta_ctx *ctx = vb2_get_drv_priv(vq);
  1178. struct delta_dev *delta = ctx->dev;
  1179. struct delta_streaminfo *streaminfo = &ctx->streaminfo;
  1180. struct delta_frameinfo *frameinfo = &ctx->frameinfo;
  1181. unsigned int size = frameinfo->size;
  1182. /*
  1183. * the number of output buffers needed for decoding =
  1184. * user need (*num_buffers given, usually for display pipeline) +
  1185. * stream need (streaminfo->dpb) +
  1186. * decoding peak smoothing (depends on DELTA IP perf)
  1187. */
  1188. if (*num_buffers < DELTA_MIN_FRAME_USER) {
  1189. dev_dbg(delta->dev,
  1190. "%s num_buffers too low (%d), increasing to %d\n",
  1191. ctx->name, *num_buffers, DELTA_MIN_FRAME_USER);
  1192. *num_buffers = DELTA_MIN_FRAME_USER;
  1193. }
  1194. *num_buffers += streaminfo->dpb + DELTA_PEAK_FRAME_SMOOTHING;
  1195. if (*num_buffers > DELTA_MAX_FRAMES) {
  1196. dev_dbg(delta->dev,
  1197. "%s output frame count too high (%d), cut to %d\n",
  1198. ctx->name, *num_buffers, DELTA_MAX_FRAMES);
  1199. *num_buffers = DELTA_MAX_FRAMES;
  1200. }
  1201. if (*num_planes)
  1202. return sizes[0] < size ? -EINVAL : 0;
  1203. /* single plane for Y and CbCr */
  1204. *num_planes = 1;
  1205. sizes[0] = size;
  1206. ctx->nb_of_frames = 0;
  1207. return 0;
  1208. }
  1209. static int delta_vb2_frame_prepare(struct vb2_buffer *vb)
  1210. {
  1211. struct vb2_queue *q = vb->vb2_queue;
  1212. struct delta_ctx *ctx = vb2_get_drv_priv(q);
  1213. struct delta_dev *delta = ctx->dev;
  1214. struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
  1215. struct delta_frame *frame = to_frame(vbuf);
  1216. int ret = 0;
  1217. if (!frame->prepared) {
  1218. frame->index = vbuf->vb2_buf.index;
  1219. frame->vaddr = vb2_plane_vaddr(&vbuf->vb2_buf, 0);
  1220. frame->paddr = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0);
  1221. frame->info = ctx->frameinfo;
  1222. ret = delta_setup_frame(ctx, frame);
  1223. if (ret) {
  1224. dev_err(delta->dev,
  1225. "%s setup_frame() failed (%d)\n",
  1226. ctx->name, ret);
  1227. return ret;
  1228. }
  1229. frame->prepared = true;
  1230. dev_dbg(delta->dev,
  1231. "%s frame[%d] prepared; virt=0x%p, phy=0x%pad\n",
  1232. ctx->name, vb->index, frame->vaddr,
  1233. &frame->paddr);
  1234. }
  1235. frame->flags = vbuf->flags;
  1236. return 0;
  1237. }
  1238. static void delta_vb2_frame_finish(struct vb2_buffer *vb)
  1239. {
  1240. struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
  1241. struct delta_frame *frame = to_frame(vbuf);
  1242. /* update V4L2 fields for user */
  1243. vb2_set_plane_payload(&vbuf->vb2_buf, 0, frame->info.size);
  1244. vb->timestamp = frame->dts;
  1245. vbuf->field = frame->field;
  1246. vbuf->flags = frame->flags;
  1247. }
  1248. static void delta_vb2_frame_queue(struct vb2_buffer *vb)
  1249. {
  1250. struct vb2_queue *q = vb->vb2_queue;
  1251. struct delta_ctx *ctx = vb2_get_drv_priv(q);
  1252. struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
  1253. struct delta_frame *frame = to_frame(vbuf);
  1254. if (ctx->state == DELTA_STATE_WF_EOS) {
  1255. /* new frame available, EOS can now be completed */
  1256. delta_complete_eos(ctx, frame);
  1257. ctx->state = DELTA_STATE_EOS;
  1258. /* return, no need to recycle this buffer to decoder */
  1259. return;
  1260. }
  1261. /* recycle this frame */
  1262. delta_recycle(ctx, frame);
  1263. }
  1264. static void delta_vb2_frame_stop_streaming(struct vb2_queue *q)
  1265. {
  1266. struct delta_ctx *ctx = vb2_get_drv_priv(q);
  1267. struct vb2_v4l2_buffer *vbuf;
  1268. struct delta_frame *frame;
  1269. const struct delta_dec *dec = ctx->dec;
  1270. unsigned int i;
  1271. delta_flush_dts(ctx);
  1272. call_dec_op(dec, flush, ctx);
  1273. /*
  1274. * return all buffers to vb2 in ERROR state
  1275. * & reset each frame state to OUT
  1276. */
  1277. for (i = 0; i < ctx->nb_of_frames; i++) {
  1278. frame = ctx->frames[i];
  1279. if (!(frame->state & DELTA_FRAME_OUT)) {
  1280. vbuf = &frame->vbuf;
  1281. v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
  1282. }
  1283. frame->state = DELTA_FRAME_OUT;
  1284. }
  1285. ctx->frame_num = 0;
  1286. ctx->aborting = false;
  1287. }
  1288. /* VB2 queue ops */
  1289. static const struct vb2_ops delta_vb2_au_ops = {
  1290. .queue_setup = delta_vb2_au_queue_setup,
  1291. .buf_prepare = delta_vb2_au_prepare,
  1292. .buf_queue = delta_vb2_au_queue,
  1293. .wait_prepare = vb2_ops_wait_prepare,
  1294. .wait_finish = vb2_ops_wait_finish,
  1295. .start_streaming = delta_vb2_au_start_streaming,
  1296. .stop_streaming = delta_vb2_au_stop_streaming,
  1297. };
  1298. static const struct vb2_ops delta_vb2_frame_ops = {
  1299. .queue_setup = delta_vb2_frame_queue_setup,
  1300. .buf_prepare = delta_vb2_frame_prepare,
  1301. .buf_finish = delta_vb2_frame_finish,
  1302. .buf_queue = delta_vb2_frame_queue,
  1303. .wait_prepare = vb2_ops_wait_prepare,
  1304. .wait_finish = vb2_ops_wait_finish,
  1305. .stop_streaming = delta_vb2_frame_stop_streaming,
  1306. };
  1307. /*
  1308. * V4L2 file operations
  1309. */
  1310. static int queue_init(void *priv,
  1311. struct vb2_queue *src_vq, struct vb2_queue *dst_vq)
  1312. {
  1313. struct vb2_queue *q;
  1314. struct delta_ctx *ctx = priv;
  1315. struct delta_dev *delta = ctx->dev;
  1316. int ret;
  1317. /* setup vb2 queue for stream input */
  1318. q = src_vq;
  1319. q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
  1320. q->io_modes = VB2_MMAP | VB2_DMABUF;
  1321. q->drv_priv = ctx;
  1322. /* overload vb2 buf with private au struct */
  1323. q->buf_struct_size = sizeof(struct delta_au);
  1324. q->ops = &delta_vb2_au_ops;
  1325. q->mem_ops = &vb2_dma_contig_memops;
  1326. q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
  1327. q->lock = &delta->lock;
  1328. q->dev = delta->dev;
  1329. ret = vb2_queue_init(q);
  1330. if (ret)
  1331. return ret;
  1332. /* setup vb2 queue for frame output */
  1333. q = dst_vq;
  1334. q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1335. q->io_modes = VB2_MMAP | VB2_DMABUF;
  1336. q->drv_priv = ctx;
  1337. /* overload vb2 buf with private frame struct */
  1338. q->buf_struct_size = sizeof(struct delta_frame)
  1339. + DELTA_MAX_FRAME_PRIV_SIZE;
  1340. q->ops = &delta_vb2_frame_ops;
  1341. q->mem_ops = &vb2_dma_contig_memops;
  1342. q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
  1343. q->lock = &delta->lock;
  1344. q->dev = delta->dev;
  1345. return vb2_queue_init(q);
  1346. }
  1347. static int delta_open(struct file *file)
  1348. {
  1349. struct delta_dev *delta = video_drvdata(file);
  1350. struct delta_ctx *ctx = NULL;
  1351. int ret = 0;
  1352. mutex_lock(&delta->lock);
  1353. ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
  1354. if (!ctx) {
  1355. ret = -ENOMEM;
  1356. goto err;
  1357. }
  1358. ctx->dev = delta;
  1359. v4l2_fh_init(&ctx->fh, video_devdata(file));
  1360. file->private_data = &ctx->fh;
  1361. v4l2_fh_add(&ctx->fh);
  1362. INIT_WORK(&ctx->run_work, delta_run_work);
  1363. mutex_init(&ctx->lock);
  1364. ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(delta->m2m_dev, ctx,
  1365. queue_init);
  1366. if (IS_ERR(ctx->fh.m2m_ctx)) {
  1367. ret = PTR_ERR(ctx->fh.m2m_ctx);
  1368. dev_err(delta->dev, "%s failed to initialize m2m context (%d)\n",
  1369. DELTA_PREFIX, ret);
  1370. goto err_fh_del;
  1371. }
  1372. /*
  1373. * wait stream format to determine which
  1374. * decoder to open
  1375. */
  1376. ctx->state = DELTA_STATE_WF_FORMAT;
  1377. INIT_LIST_HEAD(&ctx->dts);
  1378. /* set the instance name */
  1379. delta->instance_id++;
  1380. snprintf(ctx->name, sizeof(ctx->name), "[%3d:----]",
  1381. delta->instance_id);
  1382. /* default parameters for frame and stream */
  1383. set_default_params(ctx);
  1384. /* enable ST231 clocks */
  1385. if (delta->clk_st231)
  1386. if (clk_prepare_enable(delta->clk_st231))
  1387. dev_warn(delta->dev, "failed to enable st231 clk\n");
  1388. /* enable FLASH_PROMIP clock */
  1389. if (delta->clk_flash_promip)
  1390. if (clk_prepare_enable(delta->clk_flash_promip))
  1391. dev_warn(delta->dev, "failed to enable delta promip clk\n");
  1392. mutex_unlock(&delta->lock);
  1393. dev_dbg(delta->dev, "%s decoder instance created\n", ctx->name);
  1394. return 0;
  1395. err_fh_del:
  1396. v4l2_fh_del(&ctx->fh);
  1397. v4l2_fh_exit(&ctx->fh);
  1398. kfree(ctx);
  1399. err:
  1400. mutex_unlock(&delta->lock);
  1401. return ret;
  1402. }
  1403. static int delta_release(struct file *file)
  1404. {
  1405. struct delta_ctx *ctx = to_ctx(file->private_data);
  1406. struct delta_dev *delta = ctx->dev;
  1407. const struct delta_dec *dec = ctx->dec;
  1408. mutex_lock(&delta->lock);
  1409. /* close decoder */
  1410. call_dec_op(dec, close, ctx);
  1411. /*
  1412. * trace a summary of instance
  1413. * before closing (debug purpose)
  1414. */
  1415. delta_trace_summary(ctx);
  1416. v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
  1417. v4l2_fh_del(&ctx->fh);
  1418. v4l2_fh_exit(&ctx->fh);
  1419. /* disable ST231 clocks */
  1420. if (delta->clk_st231)
  1421. clk_disable_unprepare(delta->clk_st231);
  1422. /* disable FLASH_PROMIP clock */
  1423. if (delta->clk_flash_promip)
  1424. clk_disable_unprepare(delta->clk_flash_promip);
  1425. dev_dbg(delta->dev, "%s decoder instance released\n", ctx->name);
  1426. kfree(ctx);
  1427. mutex_unlock(&delta->lock);
  1428. return 0;
  1429. }
  1430. /* V4L2 file ops */
  1431. static const struct v4l2_file_operations delta_fops = {
  1432. .owner = THIS_MODULE,
  1433. .open = delta_open,
  1434. .release = delta_release,
  1435. .unlocked_ioctl = video_ioctl2,
  1436. .mmap = v4l2_m2m_fop_mmap,
  1437. .poll = v4l2_m2m_fop_poll,
  1438. };
  1439. /*
  1440. * Platform device operations
  1441. */
  1442. static int delta_register_device(struct delta_dev *delta)
  1443. {
  1444. int ret;
  1445. struct video_device *vdev;
  1446. if (!delta)
  1447. return -ENODEV;
  1448. delta->m2m_dev = v4l2_m2m_init(&delta_m2m_ops);
  1449. if (IS_ERR(delta->m2m_dev)) {
  1450. dev_err(delta->dev, "%s failed to initialize v4l2-m2m device\n",
  1451. DELTA_PREFIX);
  1452. ret = PTR_ERR(delta->m2m_dev);
  1453. goto err;
  1454. }
  1455. vdev = video_device_alloc();
  1456. if (!vdev) {
  1457. dev_err(delta->dev, "%s failed to allocate video device\n",
  1458. DELTA_PREFIX);
  1459. ret = -ENOMEM;
  1460. goto err_m2m_release;
  1461. }
  1462. vdev->fops = &delta_fops;
  1463. vdev->ioctl_ops = &delta_ioctl_ops;
  1464. vdev->release = video_device_release;
  1465. vdev->lock = &delta->lock;
  1466. vdev->vfl_dir = VFL_DIR_M2M;
  1467. vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
  1468. vdev->v4l2_dev = &delta->v4l2_dev;
  1469. snprintf(vdev->name, sizeof(vdev->name), "%s-%s",
  1470. DELTA_NAME, DELTA_FW_VERSION);
  1471. ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
  1472. if (ret) {
  1473. dev_err(delta->dev, "%s failed to register video device\n",
  1474. DELTA_PREFIX);
  1475. goto err_vdev_release;
  1476. }
  1477. delta->vdev = vdev;
  1478. video_set_drvdata(vdev, delta);
  1479. return 0;
  1480. err_vdev_release:
  1481. video_device_release(vdev);
  1482. err_m2m_release:
  1483. v4l2_m2m_release(delta->m2m_dev);
  1484. err:
  1485. return ret;
  1486. }
  1487. static void delta_unregister_device(struct delta_dev *delta)
  1488. {
  1489. if (!delta)
  1490. return;
  1491. if (delta->m2m_dev)
  1492. v4l2_m2m_release(delta->m2m_dev);
  1493. video_unregister_device(delta->vdev);
  1494. }
  1495. static int delta_probe(struct platform_device *pdev)
  1496. {
  1497. struct delta_dev *delta;
  1498. struct device *dev = &pdev->dev;
  1499. int ret;
  1500. delta = devm_kzalloc(dev, sizeof(*delta), GFP_KERNEL);
  1501. if (!delta) {
  1502. ret = -ENOMEM;
  1503. goto err;
  1504. }
  1505. delta->dev = dev;
  1506. delta->pdev = pdev;
  1507. platform_set_drvdata(pdev, delta);
  1508. mutex_init(&delta->lock);
  1509. /* get clock resources */
  1510. delta->clk_delta = devm_clk_get(dev, "delta");
  1511. if (IS_ERR(delta->clk_delta)) {
  1512. dev_dbg(dev, "%s can't get delta clock\n", DELTA_PREFIX);
  1513. delta->clk_delta = NULL;
  1514. }
  1515. delta->clk_st231 = devm_clk_get(dev, "delta-st231");
  1516. if (IS_ERR(delta->clk_st231)) {
  1517. dev_dbg(dev, "%s can't get delta-st231 clock\n", DELTA_PREFIX);
  1518. delta->clk_st231 = NULL;
  1519. }
  1520. delta->clk_flash_promip = devm_clk_get(dev, "delta-flash-promip");
  1521. if (IS_ERR(delta->clk_flash_promip)) {
  1522. dev_dbg(dev, "%s can't get delta-flash-promip clock\n",
  1523. DELTA_PREFIX);
  1524. delta->clk_flash_promip = NULL;
  1525. }
  1526. /* init pm_runtime used for power management */
  1527. pm_runtime_set_autosuspend_delay(dev, DELTA_HW_AUTOSUSPEND_DELAY_MS);
  1528. pm_runtime_use_autosuspend(dev);
  1529. pm_runtime_set_suspended(dev);
  1530. pm_runtime_enable(dev);
  1531. /* init firmware ipc channel */
  1532. ret = delta_ipc_init(delta);
  1533. if (ret) {
  1534. dev_err(delta->dev, "%s failed to initialize firmware ipc channel\n",
  1535. DELTA_PREFIX);
  1536. goto err;
  1537. }
  1538. /* register all available decoders */
  1539. register_decoders(delta);
  1540. /* register all supported formats */
  1541. register_formats(delta);
  1542. /* register on V4L2 */
  1543. ret = v4l2_device_register(dev, &delta->v4l2_dev);
  1544. if (ret) {
  1545. dev_err(delta->dev, "%s failed to register V4L2 device\n",
  1546. DELTA_PREFIX);
  1547. goto err;
  1548. }
  1549. delta->work_queue = create_workqueue(DELTA_NAME);
  1550. if (!delta->work_queue) {
  1551. dev_err(delta->dev, "%s failed to allocate work queue\n",
  1552. DELTA_PREFIX);
  1553. ret = -ENOMEM;
  1554. goto err_v4l2;
  1555. }
  1556. /* register device */
  1557. ret = delta_register_device(delta);
  1558. if (ret)
  1559. goto err_work_queue;
  1560. dev_info(dev, "%s %s registered as /dev/video%d\n",
  1561. DELTA_PREFIX, delta->vdev->name, delta->vdev->num);
  1562. return 0;
  1563. err_work_queue:
  1564. destroy_workqueue(delta->work_queue);
  1565. err_v4l2:
  1566. v4l2_device_unregister(&delta->v4l2_dev);
  1567. err:
  1568. return ret;
  1569. }
  1570. static int delta_remove(struct platform_device *pdev)
  1571. {
  1572. struct delta_dev *delta = platform_get_drvdata(pdev);
  1573. delta_ipc_exit(delta);
  1574. delta_unregister_device(delta);
  1575. destroy_workqueue(delta->work_queue);
  1576. pm_runtime_put_autosuspend(delta->dev);
  1577. pm_runtime_disable(delta->dev);
  1578. v4l2_device_unregister(&delta->v4l2_dev);
  1579. return 0;
  1580. }
  1581. static int delta_runtime_suspend(struct device *dev)
  1582. {
  1583. struct delta_dev *delta = dev_get_drvdata(dev);
  1584. if (delta->clk_delta)
  1585. clk_disable_unprepare(delta->clk_delta);
  1586. return 0;
  1587. }
  1588. static int delta_runtime_resume(struct device *dev)
  1589. {
  1590. struct delta_dev *delta = dev_get_drvdata(dev);
  1591. if (delta->clk_delta)
  1592. if (clk_prepare_enable(delta->clk_delta))
  1593. dev_warn(dev, "failed to prepare/enable delta clk\n");
  1594. return 0;
  1595. }
  1596. /* PM ops */
  1597. static const struct dev_pm_ops delta_pm_ops = {
  1598. .runtime_suspend = delta_runtime_suspend,
  1599. .runtime_resume = delta_runtime_resume,
  1600. };
  1601. static const struct of_device_id delta_match_types[] = {
  1602. {
  1603. .compatible = "st,st-delta",
  1604. },
  1605. {
  1606. /* end node */
  1607. }
  1608. };
  1609. MODULE_DEVICE_TABLE(of, delta_match_types);
  1610. static struct platform_driver delta_driver = {
  1611. .probe = delta_probe,
  1612. .remove = delta_remove,
  1613. .driver = {
  1614. .name = DELTA_NAME,
  1615. .of_match_table = delta_match_types,
  1616. .pm = &delta_pm_ops},
  1617. };
  1618. module_platform_driver(delta_driver);
  1619. MODULE_LICENSE("GPL");
  1620. MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");
  1621. MODULE_DESCRIPTION("STMicroelectronics DELTA video decoder V4L2 driver");