1c942fddfSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2cd98e85aSSteve Longerbeam /*
3cd98e85aSSteve Longerbeam * Copyright (C) 2012-2016 Mentor Graphics Inc.
4cd98e85aSSteve Longerbeam *
5cd98e85aSSteve Longerbeam * Queued image conversion support, with tiling and rotation.
6cd98e85aSSteve Longerbeam */
7cd98e85aSSteve Longerbeam
8cd98e85aSSteve Longerbeam #include <linux/interrupt.h>
9cd98e85aSSteve Longerbeam #include <linux/dma-mapping.h>
10*46f12960SAndy Shevchenko #include <linux/math.h>
11*46f12960SAndy Shevchenko
12cd98e85aSSteve Longerbeam #include <video/imx-ipu-image-convert.h>
13*46f12960SAndy Shevchenko
14cd98e85aSSteve Longerbeam #include "ipu-prv.h"
15cd98e85aSSteve Longerbeam
16cd98e85aSSteve Longerbeam /*
17cd98e85aSSteve Longerbeam * The IC Resizer has a restriction that the output frame from the
18cd98e85aSSteve Longerbeam * resizer must be 1024 or less in both width (pixels) and height
19cd98e85aSSteve Longerbeam * (lines).
20cd98e85aSSteve Longerbeam *
21cd98e85aSSteve Longerbeam * The image converter attempts to split up a conversion when
22cd98e85aSSteve Longerbeam * the desired output (converted) frame resolution exceeds the
23cd98e85aSSteve Longerbeam * IC resizer limit of 1024 in either dimension.
24cd98e85aSSteve Longerbeam *
25cd98e85aSSteve Longerbeam * If either dimension of the output frame exceeds the limit, the
26cd98e85aSSteve Longerbeam * dimension is split into 1, 2, or 4 equal stripes, for a maximum
27cd98e85aSSteve Longerbeam * of 4*4 or 16 tiles. A conversion is then carried out for each
28cd98e85aSSteve Longerbeam * tile (but taking care to pass the full frame stride length to
29cd98e85aSSteve Longerbeam * the DMA channel's parameter memory!). IDMA double-buffering is used
30cd98e85aSSteve Longerbeam * to convert each tile back-to-back when possible (see note below
31cd98e85aSSteve Longerbeam * when double_buffering boolean is set).
32cd98e85aSSteve Longerbeam *
33cd98e85aSSteve Longerbeam * Note that the input frame must be split up into the same number
34e46279f0SPhilipp Zabel * of tiles as the output frame:
35cd98e85aSSteve Longerbeam *
36e46279f0SPhilipp Zabel * +---------+-----+
37e46279f0SPhilipp Zabel * +-----+---+ | A | B |
38e46279f0SPhilipp Zabel * | A | B | | | |
39e46279f0SPhilipp Zabel * +-----+---+ --> +---------+-----+
40e46279f0SPhilipp Zabel * | C | D | | C | D |
41e46279f0SPhilipp Zabel * +-----+---+ | | |
42e46279f0SPhilipp Zabel * +---------+-----+
43e46279f0SPhilipp Zabel *
44e46279f0SPhilipp Zabel * Clockwise 90° rotations are handled by first rescaling into a
45e46279f0SPhilipp Zabel * reusable temporary tile buffer and then rotating with the 8x8
46e46279f0SPhilipp Zabel * block rotator, writing to the correct destination:
47e46279f0SPhilipp Zabel *
48e46279f0SPhilipp Zabel * +-----+-----+
49e46279f0SPhilipp Zabel * | | |
50e46279f0SPhilipp Zabel * +-----+---+ +---------+ | C | A |
51e46279f0SPhilipp Zabel * | A | B | | A,B, | | | | |
52e46279f0SPhilipp Zabel * +-----+---+ --> | C,D | | --> | | |
53e46279f0SPhilipp Zabel * | C | D | +---------+ +-----+-----+
54e46279f0SPhilipp Zabel * +-----+---+ | D | B |
55e46279f0SPhilipp Zabel * | | |
56e46279f0SPhilipp Zabel * +-----+-----+
57e46279f0SPhilipp Zabel *
58e46279f0SPhilipp Zabel * If the 8x8 block rotator is used, horizontal or vertical flipping
59e46279f0SPhilipp Zabel * is done during the rotation step, otherwise flipping is done
60e46279f0SPhilipp Zabel * during the scaling step.
61e46279f0SPhilipp Zabel * With rotation or flipping, tile order changes between input and
62e46279f0SPhilipp Zabel * output image. Tiles are numbered row major from top left to bottom
63e46279f0SPhilipp Zabel * right for both input and output image.
64cd98e85aSSteve Longerbeam */
65cd98e85aSSteve Longerbeam
66cd98e85aSSteve Longerbeam #define MAX_STRIPES_W 4
67cd98e85aSSteve Longerbeam #define MAX_STRIPES_H 4
68cd98e85aSSteve Longerbeam #define MAX_TILES (MAX_STRIPES_W * MAX_STRIPES_H)
69cd98e85aSSteve Longerbeam
70cd98e85aSSteve Longerbeam #define MIN_W 16
71cd98e85aSSteve Longerbeam #define MIN_H 8
72cd98e85aSSteve Longerbeam #define MAX_W 4096
73cd98e85aSSteve Longerbeam #define MAX_H 4096
74cd98e85aSSteve Longerbeam
75cd98e85aSSteve Longerbeam enum ipu_image_convert_type {
76cd98e85aSSteve Longerbeam IMAGE_CONVERT_IN = 0,
77cd98e85aSSteve Longerbeam IMAGE_CONVERT_OUT,
78cd98e85aSSteve Longerbeam };
79cd98e85aSSteve Longerbeam
80cd98e85aSSteve Longerbeam struct ipu_image_convert_dma_buf {
81cd98e85aSSteve Longerbeam void *virt;
82cd98e85aSSteve Longerbeam dma_addr_t phys;
83cd98e85aSSteve Longerbeam unsigned long len;
84cd98e85aSSteve Longerbeam };
85cd98e85aSSteve Longerbeam
86cd98e85aSSteve Longerbeam struct ipu_image_convert_dma_chan {
87cd98e85aSSteve Longerbeam int in;
88cd98e85aSSteve Longerbeam int out;
89cd98e85aSSteve Longerbeam int rot_in;
90cd98e85aSSteve Longerbeam int rot_out;
91cd98e85aSSteve Longerbeam int vdi_in_p;
92cd98e85aSSteve Longerbeam int vdi_in;
93cd98e85aSSteve Longerbeam int vdi_in_n;
94cd98e85aSSteve Longerbeam };
95cd98e85aSSteve Longerbeam
96cd98e85aSSteve Longerbeam /* dimensions of one tile */
97cd98e85aSSteve Longerbeam struct ipu_image_tile {
98cd98e85aSSteve Longerbeam u32 width;
99cd98e85aSSteve Longerbeam u32 height;
100571dd82cSPhilipp Zabel u32 left;
101571dd82cSPhilipp Zabel u32 top;
102cd98e85aSSteve Longerbeam /* size and strides are in bytes */
103cd98e85aSSteve Longerbeam u32 size;
104cd98e85aSSteve Longerbeam u32 stride;
105cd98e85aSSteve Longerbeam u32 rot_stride;
106cd98e85aSSteve Longerbeam /* start Y or packed offset of this tile */
107cd98e85aSSteve Longerbeam u32 offset;
108cd98e85aSSteve Longerbeam /* offset from start to tile in U plane, for planar formats */
109cd98e85aSSteve Longerbeam u32 u_off;
110cd98e85aSSteve Longerbeam /* offset from start to tile in V plane, for planar formats */
111cd98e85aSSteve Longerbeam u32 v_off;
112cd98e85aSSteve Longerbeam };
113cd98e85aSSteve Longerbeam
114cd98e85aSSteve Longerbeam struct ipu_image_convert_image {
115cd98e85aSSteve Longerbeam struct ipu_image base;
116cd98e85aSSteve Longerbeam enum ipu_image_convert_type type;
117cd98e85aSSteve Longerbeam
118cd98e85aSSteve Longerbeam const struct ipu_image_pixfmt *fmt;
119cd98e85aSSteve Longerbeam unsigned int stride;
120cd98e85aSSteve Longerbeam
121cd98e85aSSteve Longerbeam /* # of rows (horizontal stripes) if dest height is > 1024 */
122cd98e85aSSteve Longerbeam unsigned int num_rows;
123cd98e85aSSteve Longerbeam /* # of columns (vertical stripes) if dest width is > 1024 */
124cd98e85aSSteve Longerbeam unsigned int num_cols;
125cd98e85aSSteve Longerbeam
126cd98e85aSSteve Longerbeam struct ipu_image_tile tile[MAX_TILES];
127cd98e85aSSteve Longerbeam };
128cd98e85aSSteve Longerbeam
129cd98e85aSSteve Longerbeam struct ipu_image_pixfmt {
130cd98e85aSSteve Longerbeam u32 fourcc; /* V4L2 fourcc */
131cd98e85aSSteve Longerbeam int bpp; /* total bpp */
132cd98e85aSSteve Longerbeam int uv_width_dec; /* decimation in width for U/V planes */
133cd98e85aSSteve Longerbeam int uv_height_dec; /* decimation in height for U/V planes */
134cd98e85aSSteve Longerbeam bool planar; /* planar format */
135cd98e85aSSteve Longerbeam bool uv_swapped; /* U and V planes are swapped */
136cd98e85aSSteve Longerbeam bool uv_packed; /* partial planar (U and V in same plane) */
137cd98e85aSSteve Longerbeam };
138cd98e85aSSteve Longerbeam
139cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx;
140cd98e85aSSteve Longerbeam struct ipu_image_convert_chan;
141cd98e85aSSteve Longerbeam struct ipu_image_convert_priv;
142cd98e85aSSteve Longerbeam
143dd81d821SSteve Longerbeam enum eof_irq_mask {
144dd81d821SSteve Longerbeam EOF_IRQ_IN = BIT(0),
145dd81d821SSteve Longerbeam EOF_IRQ_ROT_IN = BIT(1),
146dd81d821SSteve Longerbeam EOF_IRQ_OUT = BIT(2),
147dd81d821SSteve Longerbeam EOF_IRQ_ROT_OUT = BIT(3),
148dd81d821SSteve Longerbeam };
149dd81d821SSteve Longerbeam
150dd81d821SSteve Longerbeam #define EOF_IRQ_COMPLETE (EOF_IRQ_IN | EOF_IRQ_OUT)
151dd81d821SSteve Longerbeam #define EOF_IRQ_ROT_COMPLETE (EOF_IRQ_IN | EOF_IRQ_OUT | \
152dd81d821SSteve Longerbeam EOF_IRQ_ROT_IN | EOF_IRQ_ROT_OUT)
153dd81d821SSteve Longerbeam
154cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx {
155cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan;
156cd98e85aSSteve Longerbeam
157cd98e85aSSteve Longerbeam ipu_image_convert_cb_t complete;
158cd98e85aSSteve Longerbeam void *complete_context;
159cd98e85aSSteve Longerbeam
160cd98e85aSSteve Longerbeam /* Source/destination image data and rotation mode */
161cd98e85aSSteve Longerbeam struct ipu_image_convert_image in;
162cd98e85aSSteve Longerbeam struct ipu_image_convert_image out;
163f208b26eSSteve Longerbeam struct ipu_ic_csc csc;
164cd98e85aSSteve Longerbeam enum ipu_rotate_mode rot_mode;
16570b9b6b3SPhilipp Zabel u32 downsize_coeff_h;
16670b9b6b3SPhilipp Zabel u32 downsize_coeff_v;
16770b9b6b3SPhilipp Zabel u32 image_resize_coeff_h;
16870b9b6b3SPhilipp Zabel u32 image_resize_coeff_v;
16970b9b6b3SPhilipp Zabel u32 resize_coeffs_h[MAX_STRIPES_W];
17070b9b6b3SPhilipp Zabel u32 resize_coeffs_v[MAX_STRIPES_H];
171cd98e85aSSteve Longerbeam
172cd98e85aSSteve Longerbeam /* intermediate buffer for rotation */
173cd98e85aSSteve Longerbeam struct ipu_image_convert_dma_buf rot_intermediate[2];
174cd98e85aSSteve Longerbeam
175cd98e85aSSteve Longerbeam /* current buffer number for double buffering */
176cd98e85aSSteve Longerbeam int cur_buf_num;
177cd98e85aSSteve Longerbeam
178cd98e85aSSteve Longerbeam bool aborting;
179cd98e85aSSteve Longerbeam struct completion aborted;
180cd98e85aSSteve Longerbeam
181cd98e85aSSteve Longerbeam /* can we use double-buffering for this conversion operation? */
182cd98e85aSSteve Longerbeam bool double_buffering;
183cd98e85aSSteve Longerbeam /* num_rows * num_cols */
184cd98e85aSSteve Longerbeam unsigned int num_tiles;
185cd98e85aSSteve Longerbeam /* next tile to process */
186cd98e85aSSteve Longerbeam unsigned int next_tile;
187cd98e85aSSteve Longerbeam /* where to place converted tile in dest image */
188cd98e85aSSteve Longerbeam unsigned int out_tile_map[MAX_TILES];
189cd98e85aSSteve Longerbeam
190dd81d821SSteve Longerbeam /* mask of completed EOF irqs at every tile conversion */
191dd81d821SSteve Longerbeam enum eof_irq_mask eof_mask;
192dd81d821SSteve Longerbeam
193cd98e85aSSteve Longerbeam struct list_head list;
194cd98e85aSSteve Longerbeam };
195cd98e85aSSteve Longerbeam
196cd98e85aSSteve Longerbeam struct ipu_image_convert_chan {
197cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv;
198cd98e85aSSteve Longerbeam
199cd98e85aSSteve Longerbeam enum ipu_ic_task ic_task;
200cd98e85aSSteve Longerbeam const struct ipu_image_convert_dma_chan *dma_ch;
201cd98e85aSSteve Longerbeam
202cd98e85aSSteve Longerbeam struct ipu_ic *ic;
203cd98e85aSSteve Longerbeam struct ipuv3_channel *in_chan;
204cd98e85aSSteve Longerbeam struct ipuv3_channel *out_chan;
205cd98e85aSSteve Longerbeam struct ipuv3_channel *rotation_in_chan;
206cd98e85aSSteve Longerbeam struct ipuv3_channel *rotation_out_chan;
207cd98e85aSSteve Longerbeam
208cd98e85aSSteve Longerbeam /* the IPU end-of-frame irqs */
209dd81d821SSteve Longerbeam int in_eof_irq;
210dd81d821SSteve Longerbeam int rot_in_eof_irq;
211cd98e85aSSteve Longerbeam int out_eof_irq;
212cd98e85aSSteve Longerbeam int rot_out_eof_irq;
213cd98e85aSSteve Longerbeam
214cd98e85aSSteve Longerbeam spinlock_t irqlock;
215cd98e85aSSteve Longerbeam
216cd98e85aSSteve Longerbeam /* list of convert contexts */
217cd98e85aSSteve Longerbeam struct list_head ctx_list;
218cd98e85aSSteve Longerbeam /* queue of conversion runs */
219cd98e85aSSteve Longerbeam struct list_head pending_q;
220cd98e85aSSteve Longerbeam /* queue of completed runs */
221cd98e85aSSteve Longerbeam struct list_head done_q;
222cd98e85aSSteve Longerbeam
223cd98e85aSSteve Longerbeam /* the current conversion run */
224cd98e85aSSteve Longerbeam struct ipu_image_convert_run *current_run;
225cd98e85aSSteve Longerbeam };
226cd98e85aSSteve Longerbeam
227cd98e85aSSteve Longerbeam struct ipu_image_convert_priv {
228cd98e85aSSteve Longerbeam struct ipu_image_convert_chan chan[IC_NUM_TASKS];
229cd98e85aSSteve Longerbeam struct ipu_soc *ipu;
230cd98e85aSSteve Longerbeam };
231cd98e85aSSteve Longerbeam
232cd98e85aSSteve Longerbeam static const struct ipu_image_convert_dma_chan
233cd98e85aSSteve Longerbeam image_convert_dma_chan[IC_NUM_TASKS] = {
234cd98e85aSSteve Longerbeam [IC_TASK_VIEWFINDER] = {
235cd98e85aSSteve Longerbeam .in = IPUV3_CHANNEL_MEM_IC_PRP_VF,
236cd98e85aSSteve Longerbeam .out = IPUV3_CHANNEL_IC_PRP_VF_MEM,
237cd98e85aSSteve Longerbeam .rot_in = IPUV3_CHANNEL_MEM_ROT_VF,
238cd98e85aSSteve Longerbeam .rot_out = IPUV3_CHANNEL_ROT_VF_MEM,
239cd98e85aSSteve Longerbeam .vdi_in_p = IPUV3_CHANNEL_MEM_VDI_PREV,
240cd98e85aSSteve Longerbeam .vdi_in = IPUV3_CHANNEL_MEM_VDI_CUR,
241cd98e85aSSteve Longerbeam .vdi_in_n = IPUV3_CHANNEL_MEM_VDI_NEXT,
242cd98e85aSSteve Longerbeam },
243cd98e85aSSteve Longerbeam [IC_TASK_POST_PROCESSOR] = {
244cd98e85aSSteve Longerbeam .in = IPUV3_CHANNEL_MEM_IC_PP,
245cd98e85aSSteve Longerbeam .out = IPUV3_CHANNEL_IC_PP_MEM,
246cd98e85aSSteve Longerbeam .rot_in = IPUV3_CHANNEL_MEM_ROT_PP,
247cd98e85aSSteve Longerbeam .rot_out = IPUV3_CHANNEL_ROT_PP_MEM,
248cd98e85aSSteve Longerbeam },
249cd98e85aSSteve Longerbeam };
250cd98e85aSSteve Longerbeam
251cd98e85aSSteve Longerbeam static const struct ipu_image_pixfmt image_convert_formats[] = {
252cd98e85aSSteve Longerbeam {
253cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_RGB565,
254cd98e85aSSteve Longerbeam .bpp = 16,
255cd98e85aSSteve Longerbeam }, {
256cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_RGB24,
257cd98e85aSSteve Longerbeam .bpp = 24,
258cd98e85aSSteve Longerbeam }, {
259cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_BGR24,
260cd98e85aSSteve Longerbeam .bpp = 24,
261cd98e85aSSteve Longerbeam }, {
262cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_RGB32,
263cd98e85aSSteve Longerbeam .bpp = 32,
264cd98e85aSSteve Longerbeam }, {
265cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_BGR32,
266cd98e85aSSteve Longerbeam .bpp = 32,
267cd98e85aSSteve Longerbeam }, {
2685c41bb60SPhilipp Zabel .fourcc = V4L2_PIX_FMT_XRGB32,
2695c41bb60SPhilipp Zabel .bpp = 32,
2705c41bb60SPhilipp Zabel }, {
2715c41bb60SPhilipp Zabel .fourcc = V4L2_PIX_FMT_XBGR32,
2725c41bb60SPhilipp Zabel .bpp = 32,
2735c41bb60SPhilipp Zabel }, {
2749b75651fSPhilipp Zabel .fourcc = V4L2_PIX_FMT_BGRX32,
2759b75651fSPhilipp Zabel .bpp = 32,
2769b75651fSPhilipp Zabel }, {
2779b75651fSPhilipp Zabel .fourcc = V4L2_PIX_FMT_RGBX32,
2789b75651fSPhilipp Zabel .bpp = 32,
2799b75651fSPhilipp Zabel }, {
280cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_YUYV,
281cd98e85aSSteve Longerbeam .bpp = 16,
282cd98e85aSSteve Longerbeam .uv_width_dec = 2,
283cd98e85aSSteve Longerbeam .uv_height_dec = 1,
284cd98e85aSSteve Longerbeam }, {
285cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_UYVY,
286cd98e85aSSteve Longerbeam .bpp = 16,
287cd98e85aSSteve Longerbeam .uv_width_dec = 2,
288cd98e85aSSteve Longerbeam .uv_height_dec = 1,
289cd98e85aSSteve Longerbeam }, {
290cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_YUV420,
291cd98e85aSSteve Longerbeam .bpp = 12,
292cd98e85aSSteve Longerbeam .planar = true,
293cd98e85aSSteve Longerbeam .uv_width_dec = 2,
294cd98e85aSSteve Longerbeam .uv_height_dec = 2,
295cd98e85aSSteve Longerbeam }, {
296cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_YVU420,
297cd98e85aSSteve Longerbeam .bpp = 12,
298cd98e85aSSteve Longerbeam .planar = true,
299cd98e85aSSteve Longerbeam .uv_width_dec = 2,
300cd98e85aSSteve Longerbeam .uv_height_dec = 2,
301cd98e85aSSteve Longerbeam .uv_swapped = true,
302cd98e85aSSteve Longerbeam }, {
303cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_NV12,
304cd98e85aSSteve Longerbeam .bpp = 12,
305cd98e85aSSteve Longerbeam .planar = true,
306cd98e85aSSteve Longerbeam .uv_width_dec = 2,
307cd98e85aSSteve Longerbeam .uv_height_dec = 2,
308cd98e85aSSteve Longerbeam .uv_packed = true,
309cd98e85aSSteve Longerbeam }, {
310cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_YUV422P,
311cd98e85aSSteve Longerbeam .bpp = 16,
312cd98e85aSSteve Longerbeam .planar = true,
313cd98e85aSSteve Longerbeam .uv_width_dec = 2,
314cd98e85aSSteve Longerbeam .uv_height_dec = 1,
315cd98e85aSSteve Longerbeam }, {
316cd98e85aSSteve Longerbeam .fourcc = V4L2_PIX_FMT_NV16,
317cd98e85aSSteve Longerbeam .bpp = 16,
318cd98e85aSSteve Longerbeam .planar = true,
319cd98e85aSSteve Longerbeam .uv_width_dec = 2,
320cd98e85aSSteve Longerbeam .uv_height_dec = 1,
321cd98e85aSSteve Longerbeam .uv_packed = true,
322cd98e85aSSteve Longerbeam },
323cd98e85aSSteve Longerbeam };
324cd98e85aSSteve Longerbeam
get_format(u32 fourcc)325cd98e85aSSteve Longerbeam static const struct ipu_image_pixfmt *get_format(u32 fourcc)
326cd98e85aSSteve Longerbeam {
327cd98e85aSSteve Longerbeam const struct ipu_image_pixfmt *ret = NULL;
328cd98e85aSSteve Longerbeam unsigned int i;
329cd98e85aSSteve Longerbeam
330cd98e85aSSteve Longerbeam for (i = 0; i < ARRAY_SIZE(image_convert_formats); i++) {
331cd98e85aSSteve Longerbeam if (image_convert_formats[i].fourcc == fourcc) {
332cd98e85aSSteve Longerbeam ret = &image_convert_formats[i];
333cd98e85aSSteve Longerbeam break;
334cd98e85aSSteve Longerbeam }
335cd98e85aSSteve Longerbeam }
336cd98e85aSSteve Longerbeam
337cd98e85aSSteve Longerbeam return ret;
338cd98e85aSSteve Longerbeam }
339cd98e85aSSteve Longerbeam
dump_format(struct ipu_image_convert_ctx * ctx,struct ipu_image_convert_image * ic_image)340cd98e85aSSteve Longerbeam static void dump_format(struct ipu_image_convert_ctx *ctx,
341cd98e85aSSteve Longerbeam struct ipu_image_convert_image *ic_image)
342cd98e85aSSteve Longerbeam {
343cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
344cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
345cd98e85aSSteve Longerbeam
346cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev,
347a3f42419SPhilipp Zabel "task %u: ctx %p: %s format: %dx%d (%dx%d tiles), %c%c%c%c\n",
348cd98e85aSSteve Longerbeam chan->ic_task, ctx,
349cd98e85aSSteve Longerbeam ic_image->type == IMAGE_CONVERT_OUT ? "Output" : "Input",
350cd98e85aSSteve Longerbeam ic_image->base.pix.width, ic_image->base.pix.height,
351cd98e85aSSteve Longerbeam ic_image->num_cols, ic_image->num_rows,
352cd98e85aSSteve Longerbeam ic_image->fmt->fourcc & 0xff,
353cd98e85aSSteve Longerbeam (ic_image->fmt->fourcc >> 8) & 0xff,
354cd98e85aSSteve Longerbeam (ic_image->fmt->fourcc >> 16) & 0xff,
355cd98e85aSSteve Longerbeam (ic_image->fmt->fourcc >> 24) & 0xff);
356cd98e85aSSteve Longerbeam }
357cd98e85aSSteve Longerbeam
ipu_image_convert_enum_format(int index,u32 * fourcc)358cd98e85aSSteve Longerbeam int ipu_image_convert_enum_format(int index, u32 *fourcc)
359cd98e85aSSteve Longerbeam {
360cd98e85aSSteve Longerbeam const struct ipu_image_pixfmt *fmt;
361cd98e85aSSteve Longerbeam
362cd98e85aSSteve Longerbeam if (index >= (int)ARRAY_SIZE(image_convert_formats))
363cd98e85aSSteve Longerbeam return -EINVAL;
364cd98e85aSSteve Longerbeam
365cd98e85aSSteve Longerbeam /* Format found */
366cd98e85aSSteve Longerbeam fmt = &image_convert_formats[index];
367cd98e85aSSteve Longerbeam *fourcc = fmt->fourcc;
368cd98e85aSSteve Longerbeam return 0;
369cd98e85aSSteve Longerbeam }
370cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_enum_format);
371cd98e85aSSteve Longerbeam
free_dma_buf(struct ipu_image_convert_priv * priv,struct ipu_image_convert_dma_buf * buf)372cd98e85aSSteve Longerbeam static void free_dma_buf(struct ipu_image_convert_priv *priv,
373cd98e85aSSteve Longerbeam struct ipu_image_convert_dma_buf *buf)
374cd98e85aSSteve Longerbeam {
375cd98e85aSSteve Longerbeam if (buf->virt)
376cd98e85aSSteve Longerbeam dma_free_coherent(priv->ipu->dev,
377cd98e85aSSteve Longerbeam buf->len, buf->virt, buf->phys);
378cd98e85aSSteve Longerbeam buf->virt = NULL;
379cd98e85aSSteve Longerbeam buf->phys = 0;
380cd98e85aSSteve Longerbeam }
381cd98e85aSSteve Longerbeam
alloc_dma_buf(struct ipu_image_convert_priv * priv,struct ipu_image_convert_dma_buf * buf,int size)382cd98e85aSSteve Longerbeam static int alloc_dma_buf(struct ipu_image_convert_priv *priv,
383cd98e85aSSteve Longerbeam struct ipu_image_convert_dma_buf *buf,
384cd98e85aSSteve Longerbeam int size)
385cd98e85aSSteve Longerbeam {
386cd98e85aSSteve Longerbeam buf->len = PAGE_ALIGN(size);
387cd98e85aSSteve Longerbeam buf->virt = dma_alloc_coherent(priv->ipu->dev, buf->len, &buf->phys,
388cd98e85aSSteve Longerbeam GFP_DMA | GFP_KERNEL);
389cd98e85aSSteve Longerbeam if (!buf->virt) {
390cd98e85aSSteve Longerbeam dev_err(priv->ipu->dev, "failed to alloc dma buffer\n");
391cd98e85aSSteve Longerbeam return -ENOMEM;
392cd98e85aSSteve Longerbeam }
393cd98e85aSSteve Longerbeam
394cd98e85aSSteve Longerbeam return 0;
395cd98e85aSSteve Longerbeam }
396cd98e85aSSteve Longerbeam
num_stripes(int dim)397cd98e85aSSteve Longerbeam static inline int num_stripes(int dim)
398cd98e85aSSteve Longerbeam {
399815b02e3SPhilipp Zabel return (dim - 1) / 1024 + 1;
400cd98e85aSSteve Longerbeam }
401cd98e85aSSteve Longerbeam
40270b9b6b3SPhilipp Zabel /*
40370b9b6b3SPhilipp Zabel * Calculate downsizing coefficients, which are the same for all tiles,
404de2564c7SPhilipp Zabel * and initial bilinear resizing coefficients, which are used to find the
405de2564c7SPhilipp Zabel * best seam positions.
406de2564c7SPhilipp Zabel * Also determine the number of tiles necessary to guarantee that no tile
407de2564c7SPhilipp Zabel * is larger than 1024 pixels in either dimension at the output and between
408de2564c7SPhilipp Zabel * IC downsizing and main processing sections.
40970b9b6b3SPhilipp Zabel */
calc_image_resize_coefficients(struct ipu_image_convert_ctx * ctx,struct ipu_image * in,struct ipu_image * out)41070b9b6b3SPhilipp Zabel static int calc_image_resize_coefficients(struct ipu_image_convert_ctx *ctx,
41170b9b6b3SPhilipp Zabel struct ipu_image *in,
41270b9b6b3SPhilipp Zabel struct ipu_image *out)
41370b9b6b3SPhilipp Zabel {
41470b9b6b3SPhilipp Zabel u32 downsized_width = in->rect.width;
41570b9b6b3SPhilipp Zabel u32 downsized_height = in->rect.height;
41670b9b6b3SPhilipp Zabel u32 downsize_coeff_v = 0;
41770b9b6b3SPhilipp Zabel u32 downsize_coeff_h = 0;
41870b9b6b3SPhilipp Zabel u32 resized_width = out->rect.width;
41970b9b6b3SPhilipp Zabel u32 resized_height = out->rect.height;
42070b9b6b3SPhilipp Zabel u32 resize_coeff_h;
42170b9b6b3SPhilipp Zabel u32 resize_coeff_v;
422de2564c7SPhilipp Zabel u32 cols;
423de2564c7SPhilipp Zabel u32 rows;
42470b9b6b3SPhilipp Zabel
42570b9b6b3SPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
42670b9b6b3SPhilipp Zabel resized_width = out->rect.height;
42770b9b6b3SPhilipp Zabel resized_height = out->rect.width;
42870b9b6b3SPhilipp Zabel }
42970b9b6b3SPhilipp Zabel
43070b9b6b3SPhilipp Zabel /* Do not let invalid input lead to an endless loop below */
43170b9b6b3SPhilipp Zabel if (WARN_ON(resized_width == 0 || resized_height == 0))
43270b9b6b3SPhilipp Zabel return -EINVAL;
43370b9b6b3SPhilipp Zabel
434de2564c7SPhilipp Zabel while (downsized_width >= resized_width * 2) {
43570b9b6b3SPhilipp Zabel downsized_width >>= 1;
43670b9b6b3SPhilipp Zabel downsize_coeff_h++;
43770b9b6b3SPhilipp Zabel }
43870b9b6b3SPhilipp Zabel
439de2564c7SPhilipp Zabel while (downsized_height >= resized_height * 2) {
44070b9b6b3SPhilipp Zabel downsized_height >>= 1;
44170b9b6b3SPhilipp Zabel downsize_coeff_v++;
44270b9b6b3SPhilipp Zabel }
44370b9b6b3SPhilipp Zabel
44470b9b6b3SPhilipp Zabel /*
44570b9b6b3SPhilipp Zabel * Calculate the bilinear resizing coefficients that could be used if
44670b9b6b3SPhilipp Zabel * we were converting with a single tile. The bottom right output pixel
44770b9b6b3SPhilipp Zabel * should sample as close as possible to the bottom right input pixel
44870b9b6b3SPhilipp Zabel * out of the decimator, but not overshoot it:
44970b9b6b3SPhilipp Zabel */
45070b9b6b3SPhilipp Zabel resize_coeff_h = 8192 * (downsized_width - 1) / (resized_width - 1);
45170b9b6b3SPhilipp Zabel resize_coeff_v = 8192 * (downsized_height - 1) / (resized_height - 1);
45270b9b6b3SPhilipp Zabel
453de2564c7SPhilipp Zabel /*
454de2564c7SPhilipp Zabel * Both the output of the IC downsizing section before being passed to
455de2564c7SPhilipp Zabel * the IC main processing section and the final output of the IC main
456de2564c7SPhilipp Zabel * processing section must be <= 1024 pixels in both dimensions.
457de2564c7SPhilipp Zabel */
458de2564c7SPhilipp Zabel cols = num_stripes(max_t(u32, downsized_width, resized_width));
459de2564c7SPhilipp Zabel rows = num_stripes(max_t(u32, downsized_height, resized_height));
460de2564c7SPhilipp Zabel
46170b9b6b3SPhilipp Zabel dev_dbg(ctx->chan->priv->ipu->dev,
46270b9b6b3SPhilipp Zabel "%s: hscale: >>%u, *8192/%u vscale: >>%u, *8192/%u, %ux%u tiles\n",
46370b9b6b3SPhilipp Zabel __func__, downsize_coeff_h, resize_coeff_h, downsize_coeff_v,
464de2564c7SPhilipp Zabel resize_coeff_v, cols, rows);
46570b9b6b3SPhilipp Zabel
46670b9b6b3SPhilipp Zabel if (downsize_coeff_h > 2 || downsize_coeff_v > 2 ||
46770b9b6b3SPhilipp Zabel resize_coeff_h > 0x3fff || resize_coeff_v > 0x3fff)
46870b9b6b3SPhilipp Zabel return -EINVAL;
46970b9b6b3SPhilipp Zabel
47070b9b6b3SPhilipp Zabel ctx->downsize_coeff_h = downsize_coeff_h;
47170b9b6b3SPhilipp Zabel ctx->downsize_coeff_v = downsize_coeff_v;
47270b9b6b3SPhilipp Zabel ctx->image_resize_coeff_h = resize_coeff_h;
47370b9b6b3SPhilipp Zabel ctx->image_resize_coeff_v = resize_coeff_v;
474de2564c7SPhilipp Zabel ctx->in.num_cols = cols;
475de2564c7SPhilipp Zabel ctx->in.num_rows = rows;
47670b9b6b3SPhilipp Zabel
47770b9b6b3SPhilipp Zabel return 0;
47870b9b6b3SPhilipp Zabel }
47970b9b6b3SPhilipp Zabel
48064fbae5eSPhilipp Zabel #define round_closest(x, y) round_down((x) + (y)/2, (y))
48164fbae5eSPhilipp Zabel
48264fbae5eSPhilipp Zabel /*
483ca84b1b8SPhilipp Zabel * Find the best aligned seam position for the given column / row index.
48464fbae5eSPhilipp Zabel * Rotation and image offsets are out of scope.
48564fbae5eSPhilipp Zabel *
486ca84b1b8SPhilipp Zabel * @index: column / row index, used to calculate valid interval
48764fbae5eSPhilipp Zabel * @in_edge: input right / bottom edge
48864fbae5eSPhilipp Zabel * @out_edge: output right / bottom edge
48964fbae5eSPhilipp Zabel * @in_align: input alignment, either horizontal 8-byte line start address
49064fbae5eSPhilipp Zabel * alignment, or pixel alignment due to image format
49164fbae5eSPhilipp Zabel * @out_align: output alignment, either horizontal 8-byte line start address
49264fbae5eSPhilipp Zabel * alignment, or pixel alignment due to image format or rotator
49364fbae5eSPhilipp Zabel * block size
49464fbae5eSPhilipp Zabel * @in_burst: horizontal input burst size in case of horizontal flip
49564fbae5eSPhilipp Zabel * @out_burst: horizontal output burst size or rotator block size
49664fbae5eSPhilipp Zabel * @downsize_coeff: downsizing section coefficient
49764fbae5eSPhilipp Zabel * @resize_coeff: main processing section resizing coefficient
49864fbae5eSPhilipp Zabel * @_in_seam: aligned input seam position return value
49964fbae5eSPhilipp Zabel * @_out_seam: aligned output seam position return value
50064fbae5eSPhilipp Zabel */
find_best_seam(struct ipu_image_convert_ctx * ctx,unsigned int index,unsigned int in_edge,unsigned int out_edge,unsigned int in_align,unsigned int out_align,unsigned int in_burst,unsigned int out_burst,unsigned int downsize_coeff,unsigned int resize_coeff,u32 * _in_seam,u32 * _out_seam)50164fbae5eSPhilipp Zabel static void find_best_seam(struct ipu_image_convert_ctx *ctx,
502ca84b1b8SPhilipp Zabel unsigned int index,
50364fbae5eSPhilipp Zabel unsigned int in_edge,
50464fbae5eSPhilipp Zabel unsigned int out_edge,
50564fbae5eSPhilipp Zabel unsigned int in_align,
50664fbae5eSPhilipp Zabel unsigned int out_align,
50764fbae5eSPhilipp Zabel unsigned int in_burst,
50864fbae5eSPhilipp Zabel unsigned int out_burst,
50964fbae5eSPhilipp Zabel unsigned int downsize_coeff,
51064fbae5eSPhilipp Zabel unsigned int resize_coeff,
51164fbae5eSPhilipp Zabel u32 *_in_seam,
51264fbae5eSPhilipp Zabel u32 *_out_seam)
51364fbae5eSPhilipp Zabel {
51464fbae5eSPhilipp Zabel struct device *dev = ctx->chan->priv->ipu->dev;
51564fbae5eSPhilipp Zabel unsigned int out_pos;
51664fbae5eSPhilipp Zabel /* Input / output seam position candidates */
51764fbae5eSPhilipp Zabel unsigned int out_seam = 0;
51864fbae5eSPhilipp Zabel unsigned int in_seam = 0;
51964fbae5eSPhilipp Zabel unsigned int min_diff = UINT_MAX;
520ca84b1b8SPhilipp Zabel unsigned int out_start;
521ca84b1b8SPhilipp Zabel unsigned int out_end;
5222e67a553SPhilipp Zabel unsigned int in_start;
5232e67a553SPhilipp Zabel unsigned int in_end;
524ca84b1b8SPhilipp Zabel
525ca84b1b8SPhilipp Zabel /* Start within 1024 pixels of the right / bottom edge */
52682c3e948SPhilipp Zabel out_start = max_t(int, index * out_align, out_edge - 1024);
527ca84b1b8SPhilipp Zabel /* End before having to add more columns to the left / rows above */
52882c3e948SPhilipp Zabel out_end = min_t(unsigned int, out_edge, index * 1024 + 1);
52964fbae5eSPhilipp Zabel
53064fbae5eSPhilipp Zabel /*
5312e67a553SPhilipp Zabel * Limit input seam position to make sure that the downsized input tile
5322e67a553SPhilipp Zabel * to the right or bottom does not exceed 1024 pixels.
5332e67a553SPhilipp Zabel */
5342e67a553SPhilipp Zabel in_start = max_t(int, index * in_align,
5352e67a553SPhilipp Zabel in_edge - (1024 << downsize_coeff));
5362e67a553SPhilipp Zabel in_end = min_t(unsigned int, in_edge,
5372e67a553SPhilipp Zabel index * (1024 << downsize_coeff) + 1);
5382e67a553SPhilipp Zabel
5392e67a553SPhilipp Zabel /*
54064fbae5eSPhilipp Zabel * Output tiles must start at a multiple of 8 bytes horizontally and
54164fbae5eSPhilipp Zabel * possibly at an even line horizontally depending on the pixel format.
54264fbae5eSPhilipp Zabel * Only consider output aligned positions for the seam.
54364fbae5eSPhilipp Zabel */
54464fbae5eSPhilipp Zabel out_start = round_up(out_start, out_align);
54564fbae5eSPhilipp Zabel for (out_pos = out_start; out_pos < out_end; out_pos += out_align) {
54664fbae5eSPhilipp Zabel unsigned int in_pos;
54764fbae5eSPhilipp Zabel unsigned int in_pos_aligned;
5482e67a553SPhilipp Zabel unsigned int in_pos_rounded;
549*46f12960SAndy Shevchenko unsigned int diff;
55064fbae5eSPhilipp Zabel
55164fbae5eSPhilipp Zabel /*
55264fbae5eSPhilipp Zabel * Tiles in the right row / bottom column may not be allowed to
55364fbae5eSPhilipp Zabel * overshoot horizontally / vertically. out_burst may be the
55464fbae5eSPhilipp Zabel * actual DMA burst size, or the rotator block size.
55564fbae5eSPhilipp Zabel */
55664fbae5eSPhilipp Zabel if ((out_burst > 1) && (out_edge - out_pos) % out_burst)
55764fbae5eSPhilipp Zabel continue;
55864fbae5eSPhilipp Zabel
55964fbae5eSPhilipp Zabel /*
56064fbae5eSPhilipp Zabel * Input sample position, corresponding to out_pos, 19.13 fixed
56164fbae5eSPhilipp Zabel * point.
56264fbae5eSPhilipp Zabel */
56364fbae5eSPhilipp Zabel in_pos = (out_pos * resize_coeff) << downsize_coeff;
56464fbae5eSPhilipp Zabel /*
56564fbae5eSPhilipp Zabel * The closest input sample position that we could actually
56664fbae5eSPhilipp Zabel * start the input tile at, 19.13 fixed point.
56764fbae5eSPhilipp Zabel */
56864fbae5eSPhilipp Zabel in_pos_aligned = round_closest(in_pos, 8192U * in_align);
5692e67a553SPhilipp Zabel /* Convert 19.13 fixed point to integer */
5702e67a553SPhilipp Zabel in_pos_rounded = in_pos_aligned / 8192U;
5712e67a553SPhilipp Zabel
5722e67a553SPhilipp Zabel if (in_pos_rounded < in_start)
5732e67a553SPhilipp Zabel continue;
5742e67a553SPhilipp Zabel if (in_pos_rounded >= in_end)
5752e67a553SPhilipp Zabel break;
57664fbae5eSPhilipp Zabel
57764fbae5eSPhilipp Zabel if ((in_burst > 1) &&
5782e67a553SPhilipp Zabel (in_edge - in_pos_rounded) % in_burst)
57964fbae5eSPhilipp Zabel continue;
58064fbae5eSPhilipp Zabel
581*46f12960SAndy Shevchenko diff = abs_diff(in_pos, in_pos_aligned);
582*46f12960SAndy Shevchenko if (diff < min_diff) {
5832e67a553SPhilipp Zabel in_seam = in_pos_rounded;
58464fbae5eSPhilipp Zabel out_seam = out_pos;
585*46f12960SAndy Shevchenko min_diff = diff;
58664fbae5eSPhilipp Zabel }
58764fbae5eSPhilipp Zabel }
58864fbae5eSPhilipp Zabel
58964fbae5eSPhilipp Zabel *_out_seam = out_seam;
5902e67a553SPhilipp Zabel *_in_seam = in_seam;
59164fbae5eSPhilipp Zabel
5922e67a553SPhilipp Zabel dev_dbg(dev, "%s: out_seam %u(%u) in [%u, %u], in_seam %u(%u) in [%u, %u] diff %u.%03u\n",
59364fbae5eSPhilipp Zabel __func__, out_seam, out_align, out_start, out_end,
5942e67a553SPhilipp Zabel in_seam, in_align, in_start, in_end, min_diff / 8192,
59564fbae5eSPhilipp Zabel DIV_ROUND_CLOSEST(min_diff % 8192 * 1000, 8192));
59664fbae5eSPhilipp Zabel }
59764fbae5eSPhilipp Zabel
59864fbae5eSPhilipp Zabel /*
59964fbae5eSPhilipp Zabel * Tile left edges are required to be aligned to multiples of 8 bytes
60064fbae5eSPhilipp Zabel * by the IDMAC.
60164fbae5eSPhilipp Zabel */
tile_left_align(const struct ipu_image_pixfmt * fmt)60264fbae5eSPhilipp Zabel static inline u32 tile_left_align(const struct ipu_image_pixfmt *fmt)
60364fbae5eSPhilipp Zabel {
60464fbae5eSPhilipp Zabel if (fmt->planar)
60564fbae5eSPhilipp Zabel return fmt->uv_packed ? 8 : 8 * fmt->uv_width_dec;
60664fbae5eSPhilipp Zabel else
60764fbae5eSPhilipp Zabel return fmt->bpp == 32 ? 2 : fmt->bpp == 16 ? 4 : 8;
60864fbae5eSPhilipp Zabel }
60964fbae5eSPhilipp Zabel
61064fbae5eSPhilipp Zabel /*
61164fbae5eSPhilipp Zabel * Tile top edge alignment is only limited by chroma subsampling.
61264fbae5eSPhilipp Zabel */
tile_top_align(const struct ipu_image_pixfmt * fmt)61364fbae5eSPhilipp Zabel static inline u32 tile_top_align(const struct ipu_image_pixfmt *fmt)
61464fbae5eSPhilipp Zabel {
61564fbae5eSPhilipp Zabel return fmt->uv_height_dec > 1 ? 2 : 1;
61664fbae5eSPhilipp Zabel }
61764fbae5eSPhilipp Zabel
tile_width_align(enum ipu_image_convert_type type,const struct ipu_image_pixfmt * fmt,enum ipu_rotate_mode rot_mode)618ff652fcfSPhilipp Zabel static inline u32 tile_width_align(enum ipu_image_convert_type type,
619ff652fcfSPhilipp Zabel const struct ipu_image_pixfmt *fmt,
620ff652fcfSPhilipp Zabel enum ipu_rotate_mode rot_mode)
62176e77bf5SPhilipp Zabel {
622ff652fcfSPhilipp Zabel if (type == IMAGE_CONVERT_IN) {
623ff652fcfSPhilipp Zabel /*
624ff652fcfSPhilipp Zabel * The IC burst reads 8 pixels at a time. Reading beyond the
625ff652fcfSPhilipp Zabel * end of the line is usually acceptable. Those pixels are
626ff652fcfSPhilipp Zabel * ignored, unless the IC has to write the scaled line in
627ff652fcfSPhilipp Zabel * reverse.
628ff652fcfSPhilipp Zabel */
629ff652fcfSPhilipp Zabel return (!ipu_rot_mode_is_irt(rot_mode) &&
630ff652fcfSPhilipp Zabel (rot_mode & IPU_ROT_BIT_HFLIP)) ? 8 : 2;
63176e77bf5SPhilipp Zabel }
63276e77bf5SPhilipp Zabel
63376e77bf5SPhilipp Zabel /*
634ff652fcfSPhilipp Zabel * Align to 16x16 pixel blocks for planar 4:2:0 chroma subsampled
635ff652fcfSPhilipp Zabel * formats to guarantee 8-byte aligned line start addresses in the
636ff652fcfSPhilipp Zabel * chroma planes when IRT is used. Align to 8x8 pixel IRT block size
637ff652fcfSPhilipp Zabel * for all other formats.
63876e77bf5SPhilipp Zabel */
639ff652fcfSPhilipp Zabel return (ipu_rot_mode_is_irt(rot_mode) &&
640ff652fcfSPhilipp Zabel fmt->planar && !fmt->uv_packed) ?
641ff652fcfSPhilipp Zabel 8 * fmt->uv_width_dec : 8;
642ff652fcfSPhilipp Zabel }
643ff652fcfSPhilipp Zabel
tile_height_align(enum ipu_image_convert_type type,const struct ipu_image_pixfmt * fmt,enum ipu_rotate_mode rot_mode)64476e77bf5SPhilipp Zabel static inline u32 tile_height_align(enum ipu_image_convert_type type,
645ff652fcfSPhilipp Zabel const struct ipu_image_pixfmt *fmt,
64676e77bf5SPhilipp Zabel enum ipu_rotate_mode rot_mode)
64776e77bf5SPhilipp Zabel {
648ff652fcfSPhilipp Zabel if (type == IMAGE_CONVERT_IN || !ipu_rot_mode_is_irt(rot_mode))
649ff652fcfSPhilipp Zabel return 2;
650ff652fcfSPhilipp Zabel
651ff652fcfSPhilipp Zabel /*
652ff652fcfSPhilipp Zabel * Align to 16x16 pixel blocks for planar 4:2:0 chroma subsampled
653ff652fcfSPhilipp Zabel * formats to guarantee 8-byte aligned line start addresses in the
654ff652fcfSPhilipp Zabel * chroma planes when IRT is used. Align to 8x8 pixel IRT block size
655ff652fcfSPhilipp Zabel * for all other formats.
656ff652fcfSPhilipp Zabel */
657ff652fcfSPhilipp Zabel return (fmt->planar && !fmt->uv_packed) ? 8 * fmt->uv_width_dec : 8;
65876e77bf5SPhilipp Zabel }
65976e77bf5SPhilipp Zabel
66064fbae5eSPhilipp Zabel /*
66164fbae5eSPhilipp Zabel * Fill in left position and width and for all tiles in an input column, and
66264fbae5eSPhilipp Zabel * for all corresponding output tiles. If the 90° rotator is used, the output
66364fbae5eSPhilipp Zabel * tiles are in a row, and output tile top position and height are set.
66464fbae5eSPhilipp Zabel */
fill_tile_column(struct ipu_image_convert_ctx * ctx,unsigned int col,struct ipu_image_convert_image * in,unsigned int in_left,unsigned int in_width,struct ipu_image_convert_image * out,unsigned int out_left,unsigned int out_width)66564fbae5eSPhilipp Zabel static void fill_tile_column(struct ipu_image_convert_ctx *ctx,
66664fbae5eSPhilipp Zabel unsigned int col,
66764fbae5eSPhilipp Zabel struct ipu_image_convert_image *in,
66864fbae5eSPhilipp Zabel unsigned int in_left, unsigned int in_width,
66964fbae5eSPhilipp Zabel struct ipu_image_convert_image *out,
67064fbae5eSPhilipp Zabel unsigned int out_left, unsigned int out_width)
67164fbae5eSPhilipp Zabel {
67264fbae5eSPhilipp Zabel unsigned int row, tile_idx;
67364fbae5eSPhilipp Zabel struct ipu_image_tile *in_tile, *out_tile;
67464fbae5eSPhilipp Zabel
67564fbae5eSPhilipp Zabel for (row = 0; row < in->num_rows; row++) {
67664fbae5eSPhilipp Zabel tile_idx = in->num_cols * row + col;
67764fbae5eSPhilipp Zabel in_tile = &in->tile[tile_idx];
67864fbae5eSPhilipp Zabel out_tile = &out->tile[ctx->out_tile_map[tile_idx]];
67964fbae5eSPhilipp Zabel
68064fbae5eSPhilipp Zabel in_tile->left = in_left;
68164fbae5eSPhilipp Zabel in_tile->width = in_width;
68264fbae5eSPhilipp Zabel
68364fbae5eSPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
68464fbae5eSPhilipp Zabel out_tile->top = out_left;
68564fbae5eSPhilipp Zabel out_tile->height = out_width;
68664fbae5eSPhilipp Zabel } else {
68764fbae5eSPhilipp Zabel out_tile->left = out_left;
68864fbae5eSPhilipp Zabel out_tile->width = out_width;
68964fbae5eSPhilipp Zabel }
69064fbae5eSPhilipp Zabel }
69164fbae5eSPhilipp Zabel }
69264fbae5eSPhilipp Zabel
69364fbae5eSPhilipp Zabel /*
69464fbae5eSPhilipp Zabel * Fill in top position and height and for all tiles in an input row, and
69564fbae5eSPhilipp Zabel * for all corresponding output tiles. If the 90° rotator is used, the output
69664fbae5eSPhilipp Zabel * tiles are in a column, and output tile left position and width are set.
69764fbae5eSPhilipp Zabel */
fill_tile_row(struct ipu_image_convert_ctx * ctx,unsigned int row,struct ipu_image_convert_image * in,unsigned int in_top,unsigned int in_height,struct ipu_image_convert_image * out,unsigned int out_top,unsigned int out_height)69864fbae5eSPhilipp Zabel static void fill_tile_row(struct ipu_image_convert_ctx *ctx, unsigned int row,
69964fbae5eSPhilipp Zabel struct ipu_image_convert_image *in,
70064fbae5eSPhilipp Zabel unsigned int in_top, unsigned int in_height,
70164fbae5eSPhilipp Zabel struct ipu_image_convert_image *out,
70264fbae5eSPhilipp Zabel unsigned int out_top, unsigned int out_height)
70364fbae5eSPhilipp Zabel {
70464fbae5eSPhilipp Zabel unsigned int col, tile_idx;
70564fbae5eSPhilipp Zabel struct ipu_image_tile *in_tile, *out_tile;
70664fbae5eSPhilipp Zabel
70764fbae5eSPhilipp Zabel for (col = 0; col < in->num_cols; col++) {
70864fbae5eSPhilipp Zabel tile_idx = in->num_cols * row + col;
70964fbae5eSPhilipp Zabel in_tile = &in->tile[tile_idx];
71064fbae5eSPhilipp Zabel out_tile = &out->tile[ctx->out_tile_map[tile_idx]];
71164fbae5eSPhilipp Zabel
71264fbae5eSPhilipp Zabel in_tile->top = in_top;
71364fbae5eSPhilipp Zabel in_tile->height = in_height;
71464fbae5eSPhilipp Zabel
71564fbae5eSPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
71664fbae5eSPhilipp Zabel out_tile->left = out_top;
71764fbae5eSPhilipp Zabel out_tile->width = out_height;
71864fbae5eSPhilipp Zabel } else {
71964fbae5eSPhilipp Zabel out_tile->top = out_top;
72064fbae5eSPhilipp Zabel out_tile->height = out_height;
72164fbae5eSPhilipp Zabel }
72264fbae5eSPhilipp Zabel }
72364fbae5eSPhilipp Zabel }
72464fbae5eSPhilipp Zabel
72564fbae5eSPhilipp Zabel /*
72664fbae5eSPhilipp Zabel * Find the best horizontal and vertical seam positions to split into tiles.
72764fbae5eSPhilipp Zabel * Minimize the fractional part of the input sampling position for the
72864fbae5eSPhilipp Zabel * top / left pixels of each tile.
72964fbae5eSPhilipp Zabel */
find_seams(struct ipu_image_convert_ctx * ctx,struct ipu_image_convert_image * in,struct ipu_image_convert_image * out)73064fbae5eSPhilipp Zabel static void find_seams(struct ipu_image_convert_ctx *ctx,
73164fbae5eSPhilipp Zabel struct ipu_image_convert_image *in,
73264fbae5eSPhilipp Zabel struct ipu_image_convert_image *out)
73364fbae5eSPhilipp Zabel {
73464fbae5eSPhilipp Zabel struct device *dev = ctx->chan->priv->ipu->dev;
73564fbae5eSPhilipp Zabel unsigned int resized_width = out->base.rect.width;
73664fbae5eSPhilipp Zabel unsigned int resized_height = out->base.rect.height;
73764fbae5eSPhilipp Zabel unsigned int col;
73864fbae5eSPhilipp Zabel unsigned int row;
73964fbae5eSPhilipp Zabel unsigned int in_left_align = tile_left_align(in->fmt);
74064fbae5eSPhilipp Zabel unsigned int in_top_align = tile_top_align(in->fmt);
74164fbae5eSPhilipp Zabel unsigned int out_left_align = tile_left_align(out->fmt);
74264fbae5eSPhilipp Zabel unsigned int out_top_align = tile_top_align(out->fmt);
743ff652fcfSPhilipp Zabel unsigned int out_width_align = tile_width_align(out->type, out->fmt,
744ff652fcfSPhilipp Zabel ctx->rot_mode);
745ff652fcfSPhilipp Zabel unsigned int out_height_align = tile_height_align(out->type, out->fmt,
74664fbae5eSPhilipp Zabel ctx->rot_mode);
74764fbae5eSPhilipp Zabel unsigned int in_right = in->base.rect.width;
74864fbae5eSPhilipp Zabel unsigned int in_bottom = in->base.rect.height;
74964fbae5eSPhilipp Zabel unsigned int out_right = out->base.rect.width;
75064fbae5eSPhilipp Zabel unsigned int out_bottom = out->base.rect.height;
75164fbae5eSPhilipp Zabel unsigned int flipped_out_left;
75264fbae5eSPhilipp Zabel unsigned int flipped_out_top;
75364fbae5eSPhilipp Zabel
75464fbae5eSPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
75564fbae5eSPhilipp Zabel /* Switch width/height and align top left to IRT block size */
75664fbae5eSPhilipp Zabel resized_width = out->base.rect.height;
75764fbae5eSPhilipp Zabel resized_height = out->base.rect.width;
75864fbae5eSPhilipp Zabel out_left_align = out_height_align;
75964fbae5eSPhilipp Zabel out_top_align = out_width_align;
76064fbae5eSPhilipp Zabel out_width_align = out_left_align;
76164fbae5eSPhilipp Zabel out_height_align = out_top_align;
76264fbae5eSPhilipp Zabel out_right = out->base.rect.height;
76364fbae5eSPhilipp Zabel out_bottom = out->base.rect.width;
76464fbae5eSPhilipp Zabel }
76564fbae5eSPhilipp Zabel
76664fbae5eSPhilipp Zabel for (col = in->num_cols - 1; col > 0; col--) {
76764fbae5eSPhilipp Zabel bool allow_in_overshoot = ipu_rot_mode_is_irt(ctx->rot_mode) ||
76864fbae5eSPhilipp Zabel !(ctx->rot_mode & IPU_ROT_BIT_HFLIP);
76964fbae5eSPhilipp Zabel bool allow_out_overshoot = (col < in->num_cols - 1) &&
77064fbae5eSPhilipp Zabel !(ctx->rot_mode & IPU_ROT_BIT_HFLIP);
77164fbae5eSPhilipp Zabel unsigned int in_left;
77264fbae5eSPhilipp Zabel unsigned int out_left;
77364fbae5eSPhilipp Zabel
77464fbae5eSPhilipp Zabel /*
77564fbae5eSPhilipp Zabel * Align input width to burst length if the scaling step flips
77664fbae5eSPhilipp Zabel * horizontally.
77764fbae5eSPhilipp Zabel */
77864fbae5eSPhilipp Zabel
779ca84b1b8SPhilipp Zabel find_best_seam(ctx, col,
78064fbae5eSPhilipp Zabel in_right, out_right,
78164fbae5eSPhilipp Zabel in_left_align, out_left_align,
78264fbae5eSPhilipp Zabel allow_in_overshoot ? 1 : 8 /* burst length */,
78364fbae5eSPhilipp Zabel allow_out_overshoot ? 1 : out_width_align,
78464fbae5eSPhilipp Zabel ctx->downsize_coeff_h, ctx->image_resize_coeff_h,
78564fbae5eSPhilipp Zabel &in_left, &out_left);
78664fbae5eSPhilipp Zabel
78764fbae5eSPhilipp Zabel if (ctx->rot_mode & IPU_ROT_BIT_HFLIP)
78864fbae5eSPhilipp Zabel flipped_out_left = resized_width - out_right;
78964fbae5eSPhilipp Zabel else
79064fbae5eSPhilipp Zabel flipped_out_left = out_left;
79164fbae5eSPhilipp Zabel
79264fbae5eSPhilipp Zabel fill_tile_column(ctx, col, in, in_left, in_right - in_left,
79364fbae5eSPhilipp Zabel out, flipped_out_left, out_right - out_left);
79464fbae5eSPhilipp Zabel
79564fbae5eSPhilipp Zabel dev_dbg(dev, "%s: col %u: %u, %u -> %u, %u\n", __func__, col,
79664fbae5eSPhilipp Zabel in_left, in_right - in_left,
79764fbae5eSPhilipp Zabel flipped_out_left, out_right - out_left);
79864fbae5eSPhilipp Zabel
79964fbae5eSPhilipp Zabel in_right = in_left;
80064fbae5eSPhilipp Zabel out_right = out_left;
80164fbae5eSPhilipp Zabel }
80264fbae5eSPhilipp Zabel
80364fbae5eSPhilipp Zabel flipped_out_left = (ctx->rot_mode & IPU_ROT_BIT_HFLIP) ?
80464fbae5eSPhilipp Zabel resized_width - out_right : 0;
80564fbae5eSPhilipp Zabel
80664fbae5eSPhilipp Zabel fill_tile_column(ctx, 0, in, 0, in_right,
80764fbae5eSPhilipp Zabel out, flipped_out_left, out_right);
80864fbae5eSPhilipp Zabel
80964fbae5eSPhilipp Zabel dev_dbg(dev, "%s: col 0: 0, %u -> %u, %u\n", __func__,
81064fbae5eSPhilipp Zabel in_right, flipped_out_left, out_right);
81164fbae5eSPhilipp Zabel
81264fbae5eSPhilipp Zabel for (row = in->num_rows - 1; row > 0; row--) {
81364fbae5eSPhilipp Zabel bool allow_overshoot = row < in->num_rows - 1;
81464fbae5eSPhilipp Zabel unsigned int in_top;
81564fbae5eSPhilipp Zabel unsigned int out_top;
81664fbae5eSPhilipp Zabel
817ca84b1b8SPhilipp Zabel find_best_seam(ctx, row,
81864fbae5eSPhilipp Zabel in_bottom, out_bottom,
81964fbae5eSPhilipp Zabel in_top_align, out_top_align,
82064fbae5eSPhilipp Zabel 1, allow_overshoot ? 1 : out_height_align,
82164fbae5eSPhilipp Zabel ctx->downsize_coeff_v, ctx->image_resize_coeff_v,
82264fbae5eSPhilipp Zabel &in_top, &out_top);
82364fbae5eSPhilipp Zabel
82464fbae5eSPhilipp Zabel if ((ctx->rot_mode & IPU_ROT_BIT_VFLIP) ^
82564fbae5eSPhilipp Zabel ipu_rot_mode_is_irt(ctx->rot_mode))
82664fbae5eSPhilipp Zabel flipped_out_top = resized_height - out_bottom;
82764fbae5eSPhilipp Zabel else
82864fbae5eSPhilipp Zabel flipped_out_top = out_top;
82964fbae5eSPhilipp Zabel
83064fbae5eSPhilipp Zabel fill_tile_row(ctx, row, in, in_top, in_bottom - in_top,
83164fbae5eSPhilipp Zabel out, flipped_out_top, out_bottom - out_top);
83264fbae5eSPhilipp Zabel
83364fbae5eSPhilipp Zabel dev_dbg(dev, "%s: row %u: %u, %u -> %u, %u\n", __func__, row,
83464fbae5eSPhilipp Zabel in_top, in_bottom - in_top,
83564fbae5eSPhilipp Zabel flipped_out_top, out_bottom - out_top);
83664fbae5eSPhilipp Zabel
83764fbae5eSPhilipp Zabel in_bottom = in_top;
83864fbae5eSPhilipp Zabel out_bottom = out_top;
83964fbae5eSPhilipp Zabel }
84064fbae5eSPhilipp Zabel
84164fbae5eSPhilipp Zabel if ((ctx->rot_mode & IPU_ROT_BIT_VFLIP) ^
84264fbae5eSPhilipp Zabel ipu_rot_mode_is_irt(ctx->rot_mode))
84364fbae5eSPhilipp Zabel flipped_out_top = resized_height - out_bottom;
84464fbae5eSPhilipp Zabel else
84564fbae5eSPhilipp Zabel flipped_out_top = 0;
84664fbae5eSPhilipp Zabel
84764fbae5eSPhilipp Zabel fill_tile_row(ctx, 0, in, 0, in_bottom,
84864fbae5eSPhilipp Zabel out, flipped_out_top, out_bottom);
84964fbae5eSPhilipp Zabel
85064fbae5eSPhilipp Zabel dev_dbg(dev, "%s: row 0: 0, %u -> %u, %u\n", __func__,
85164fbae5eSPhilipp Zabel in_bottom, flipped_out_top, out_bottom);
85264fbae5eSPhilipp Zabel }
85364fbae5eSPhilipp Zabel
calc_tile_dimensions(struct ipu_image_convert_ctx * ctx,struct ipu_image_convert_image * image)8545fb8b650SPhilipp Zabel static int calc_tile_dimensions(struct ipu_image_convert_ctx *ctx,
855cd98e85aSSteve Longerbeam struct ipu_image_convert_image *image)
856cd98e85aSSteve Longerbeam {
857a3f42419SPhilipp Zabel struct ipu_image_convert_chan *chan = ctx->chan;
858a3f42419SPhilipp Zabel struct ipu_image_convert_priv *priv = chan->priv;
8595fb8b650SPhilipp Zabel unsigned int max_width = 1024;
8605fb8b650SPhilipp Zabel unsigned int max_height = 1024;
861571dd82cSPhilipp Zabel unsigned int i;
862cd98e85aSSteve Longerbeam
8635fb8b650SPhilipp Zabel if (image->type == IMAGE_CONVERT_IN) {
8645fb8b650SPhilipp Zabel /* Up to 4096x4096 input tile size */
8655fb8b650SPhilipp Zabel max_width <<= ctx->downsize_coeff_h;
8665fb8b650SPhilipp Zabel max_height <<= ctx->downsize_coeff_v;
8675fb8b650SPhilipp Zabel }
8685fb8b650SPhilipp Zabel
869cd98e85aSSteve Longerbeam for (i = 0; i < ctx->num_tiles; i++) {
87064fbae5eSPhilipp Zabel struct ipu_image_tile *tile;
871571dd82cSPhilipp Zabel const unsigned int row = i / image->num_cols;
872571dd82cSPhilipp Zabel const unsigned int col = i % image->num_cols;
873cd98e85aSSteve Longerbeam
87464fbae5eSPhilipp Zabel if (image->type == IMAGE_CONVERT_OUT)
87564fbae5eSPhilipp Zabel tile = &image->tile[ctx->out_tile_map[i]];
87664fbae5eSPhilipp Zabel else
87764fbae5eSPhilipp Zabel tile = &image->tile[i];
87864fbae5eSPhilipp Zabel
879cd98e85aSSteve Longerbeam tile->size = ((tile->height * image->fmt->bpp) >> 3) *
880cd98e85aSSteve Longerbeam tile->width;
881cd98e85aSSteve Longerbeam
882cd98e85aSSteve Longerbeam if (image->fmt->planar) {
883cd98e85aSSteve Longerbeam tile->stride = tile->width;
884cd98e85aSSteve Longerbeam tile->rot_stride = tile->height;
885cd98e85aSSteve Longerbeam } else {
886cd98e85aSSteve Longerbeam tile->stride =
887cd98e85aSSteve Longerbeam (image->fmt->bpp * tile->width) >> 3;
888cd98e85aSSteve Longerbeam tile->rot_stride =
889cd98e85aSSteve Longerbeam (image->fmt->bpp * tile->height) >> 3;
890cd98e85aSSteve Longerbeam }
891a3f42419SPhilipp Zabel
892a3f42419SPhilipp Zabel dev_dbg(priv->ipu->dev,
893a3f42419SPhilipp Zabel "task %u: ctx %p: %s@[%u,%u]: %ux%u@%u,%u\n",
894a3f42419SPhilipp Zabel chan->ic_task, ctx,
895a3f42419SPhilipp Zabel image->type == IMAGE_CONVERT_IN ? "Input" : "Output",
896a3f42419SPhilipp Zabel row, col,
897a3f42419SPhilipp Zabel tile->width, tile->height, tile->left, tile->top);
8985fb8b650SPhilipp Zabel
8995fb8b650SPhilipp Zabel if (!tile->width || tile->width > max_width ||
9005fb8b650SPhilipp Zabel !tile->height || tile->height > max_height) {
9015fb8b650SPhilipp Zabel dev_err(priv->ipu->dev, "invalid %s tile size: %ux%u\n",
9025fb8b650SPhilipp Zabel image->type == IMAGE_CONVERT_IN ? "input" :
9035fb8b650SPhilipp Zabel "output", tile->width, tile->height);
9045fb8b650SPhilipp Zabel return -EINVAL;
905cd98e85aSSteve Longerbeam }
906cd98e85aSSteve Longerbeam }
907cd98e85aSSteve Longerbeam
9085fb8b650SPhilipp Zabel return 0;
9095fb8b650SPhilipp Zabel }
9105fb8b650SPhilipp Zabel
911cd98e85aSSteve Longerbeam /*
912cd98e85aSSteve Longerbeam * Use the rotation transformation to find the tile coordinates
913cd98e85aSSteve Longerbeam * (row, col) of a tile in the destination frame that corresponds
914cd98e85aSSteve Longerbeam * to the given tile coordinates of a source frame. The destination
915cd98e85aSSteve Longerbeam * coordinate is then converted to a tile index.
916cd98e85aSSteve Longerbeam */
transform_tile_index(struct ipu_image_convert_ctx * ctx,int src_row,int src_col)917cd98e85aSSteve Longerbeam static int transform_tile_index(struct ipu_image_convert_ctx *ctx,
918cd98e85aSSteve Longerbeam int src_row, int src_col)
919cd98e85aSSteve Longerbeam {
920cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
921cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
922cd98e85aSSteve Longerbeam struct ipu_image_convert_image *s_image = &ctx->in;
923cd98e85aSSteve Longerbeam struct ipu_image_convert_image *d_image = &ctx->out;
924cd98e85aSSteve Longerbeam int dst_row, dst_col;
925cd98e85aSSteve Longerbeam
926cd98e85aSSteve Longerbeam /* with no rotation it's a 1:1 mapping */
927cd98e85aSSteve Longerbeam if (ctx->rot_mode == IPU_ROTATE_NONE)
928cd98e85aSSteve Longerbeam return src_row * s_image->num_cols + src_col;
929cd98e85aSSteve Longerbeam
930cd98e85aSSteve Longerbeam /*
931cd98e85aSSteve Longerbeam * before doing the transform, first we have to translate
932cd98e85aSSteve Longerbeam * source row,col for an origin in the center of s_image
933cd98e85aSSteve Longerbeam */
934cd98e85aSSteve Longerbeam src_row = src_row * 2 - (s_image->num_rows - 1);
935cd98e85aSSteve Longerbeam src_col = src_col * 2 - (s_image->num_cols - 1);
936cd98e85aSSteve Longerbeam
937cd98e85aSSteve Longerbeam /* do the rotation transform */
938cd98e85aSSteve Longerbeam if (ctx->rot_mode & IPU_ROT_BIT_90) {
939cd98e85aSSteve Longerbeam dst_col = -src_row;
940cd98e85aSSteve Longerbeam dst_row = src_col;
941cd98e85aSSteve Longerbeam } else {
942cd98e85aSSteve Longerbeam dst_col = src_col;
943cd98e85aSSteve Longerbeam dst_row = src_row;
944cd98e85aSSteve Longerbeam }
945cd98e85aSSteve Longerbeam
946cd98e85aSSteve Longerbeam /* apply flip */
947cd98e85aSSteve Longerbeam if (ctx->rot_mode & IPU_ROT_BIT_HFLIP)
948cd98e85aSSteve Longerbeam dst_col = -dst_col;
949cd98e85aSSteve Longerbeam if (ctx->rot_mode & IPU_ROT_BIT_VFLIP)
950cd98e85aSSteve Longerbeam dst_row = -dst_row;
951cd98e85aSSteve Longerbeam
952cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev, "task %u: ctx %p: [%d,%d] --> [%d,%d]\n",
953cd98e85aSSteve Longerbeam chan->ic_task, ctx, src_col, src_row, dst_col, dst_row);
954cd98e85aSSteve Longerbeam
955cd98e85aSSteve Longerbeam /*
956cd98e85aSSteve Longerbeam * finally translate dest row,col using an origin in upper
957cd98e85aSSteve Longerbeam * left of d_image
958cd98e85aSSteve Longerbeam */
959cd98e85aSSteve Longerbeam dst_row += d_image->num_rows - 1;
960cd98e85aSSteve Longerbeam dst_col += d_image->num_cols - 1;
961cd98e85aSSteve Longerbeam dst_row /= 2;
962cd98e85aSSteve Longerbeam dst_col /= 2;
963cd98e85aSSteve Longerbeam
964cd98e85aSSteve Longerbeam return dst_row * d_image->num_cols + dst_col;
965cd98e85aSSteve Longerbeam }
966cd98e85aSSteve Longerbeam
967cd98e85aSSteve Longerbeam /*
968cd98e85aSSteve Longerbeam * Fill the out_tile_map[] with transformed destination tile indeces.
969cd98e85aSSteve Longerbeam */
calc_out_tile_map(struct ipu_image_convert_ctx * ctx)970cd98e85aSSteve Longerbeam static void calc_out_tile_map(struct ipu_image_convert_ctx *ctx)
971cd98e85aSSteve Longerbeam {
972cd98e85aSSteve Longerbeam struct ipu_image_convert_image *s_image = &ctx->in;
973cd98e85aSSteve Longerbeam unsigned int row, col, tile = 0;
974cd98e85aSSteve Longerbeam
975cd98e85aSSteve Longerbeam for (row = 0; row < s_image->num_rows; row++) {
976cd98e85aSSteve Longerbeam for (col = 0; col < s_image->num_cols; col++) {
977cd98e85aSSteve Longerbeam ctx->out_tile_map[tile] =
978cd98e85aSSteve Longerbeam transform_tile_index(ctx, row, col);
979cd98e85aSSteve Longerbeam tile++;
980cd98e85aSSteve Longerbeam }
981cd98e85aSSteve Longerbeam }
982cd98e85aSSteve Longerbeam }
983cd98e85aSSteve Longerbeam
calc_tile_offsets_planar(struct ipu_image_convert_ctx * ctx,struct ipu_image_convert_image * image)984c4e45658SSteve Longerbeam static int calc_tile_offsets_planar(struct ipu_image_convert_ctx *ctx,
985cd98e85aSSteve Longerbeam struct ipu_image_convert_image *image)
986cd98e85aSSteve Longerbeam {
987cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
988cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
989cd98e85aSSteve Longerbeam const struct ipu_image_pixfmt *fmt = image->fmt;
990cd98e85aSSteve Longerbeam unsigned int row, col, tile = 0;
991571dd82cSPhilipp Zabel u32 H, top, y_stride, uv_stride;
992180a49e3SSalah Triki u32 uv_row_off, uv_col_off, uv_off, u_off, v_off;
993cd98e85aSSteve Longerbeam u32 y_row_off, y_col_off, y_off;
994cd98e85aSSteve Longerbeam u32 y_size, uv_size;
995cd98e85aSSteve Longerbeam
996cd98e85aSSteve Longerbeam /* setup some convenience vars */
997cd98e85aSSteve Longerbeam H = image->base.pix.height;
998cd98e85aSSteve Longerbeam
999cd98e85aSSteve Longerbeam y_stride = image->stride;
1000cd98e85aSSteve Longerbeam uv_stride = y_stride / fmt->uv_width_dec;
1001cd98e85aSSteve Longerbeam if (fmt->uv_packed)
1002cd98e85aSSteve Longerbeam uv_stride *= 2;
1003cd98e85aSSteve Longerbeam
1004cd98e85aSSteve Longerbeam y_size = H * y_stride;
1005cd98e85aSSteve Longerbeam uv_size = y_size / (fmt->uv_width_dec * fmt->uv_height_dec);
1006cd98e85aSSteve Longerbeam
1007cd98e85aSSteve Longerbeam for (row = 0; row < image->num_rows; row++) {
1008571dd82cSPhilipp Zabel top = image->tile[tile].top;
1009571dd82cSPhilipp Zabel y_row_off = top * y_stride;
1010571dd82cSPhilipp Zabel uv_row_off = (top * uv_stride) / fmt->uv_height_dec;
1011cd98e85aSSteve Longerbeam
1012cd98e85aSSteve Longerbeam for (col = 0; col < image->num_cols; col++) {
1013571dd82cSPhilipp Zabel y_col_off = image->tile[tile].left;
1014cd98e85aSSteve Longerbeam uv_col_off = y_col_off / fmt->uv_width_dec;
1015cd98e85aSSteve Longerbeam if (fmt->uv_packed)
1016cd98e85aSSteve Longerbeam uv_col_off *= 2;
1017cd98e85aSSteve Longerbeam
1018cd98e85aSSteve Longerbeam y_off = y_row_off + y_col_off;
1019cd98e85aSSteve Longerbeam uv_off = uv_row_off + uv_col_off;
1020cd98e85aSSteve Longerbeam
1021cd98e85aSSteve Longerbeam u_off = y_size - y_off + uv_off;
1022cd98e85aSSteve Longerbeam v_off = (fmt->uv_packed) ? 0 : u_off + uv_size;
1023180a49e3SSalah Triki if (fmt->uv_swapped)
1024180a49e3SSalah Triki swap(u_off, v_off);
1025cd98e85aSSteve Longerbeam
1026cd98e85aSSteve Longerbeam image->tile[tile].offset = y_off;
1027cd98e85aSSteve Longerbeam image->tile[tile].u_off = u_off;
1028cd98e85aSSteve Longerbeam image->tile[tile++].v_off = v_off;
1029cd98e85aSSteve Longerbeam
1030c4e45658SSteve Longerbeam if ((y_off & 0x7) || (u_off & 0x7) || (v_off & 0x7)) {
1031c4e45658SSteve Longerbeam dev_err(priv->ipu->dev,
1032c4e45658SSteve Longerbeam "task %u: ctx %p: %s@[%d,%d]: "
1033c4e45658SSteve Longerbeam "y_off %08x, u_off %08x, v_off %08x\n",
1034cd98e85aSSteve Longerbeam chan->ic_task, ctx,
1035cd98e85aSSteve Longerbeam image->type == IMAGE_CONVERT_IN ?
1036cd98e85aSSteve Longerbeam "Input" : "Output", row, col,
1037cd98e85aSSteve Longerbeam y_off, u_off, v_off);
1038c4e45658SSteve Longerbeam return -EINVAL;
1039cd98e85aSSteve Longerbeam }
1040cd98e85aSSteve Longerbeam }
1041cd98e85aSSteve Longerbeam }
1042cd98e85aSSteve Longerbeam
1043c4e45658SSteve Longerbeam return 0;
1044c4e45658SSteve Longerbeam }
1045c4e45658SSteve Longerbeam
calc_tile_offsets_packed(struct ipu_image_convert_ctx * ctx,struct ipu_image_convert_image * image)1046c4e45658SSteve Longerbeam static int calc_tile_offsets_packed(struct ipu_image_convert_ctx *ctx,
1047cd98e85aSSteve Longerbeam struct ipu_image_convert_image *image)
1048cd98e85aSSteve Longerbeam {
1049cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
1050cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1051cd98e85aSSteve Longerbeam const struct ipu_image_pixfmt *fmt = image->fmt;
1052cd98e85aSSteve Longerbeam unsigned int row, col, tile = 0;
1053571dd82cSPhilipp Zabel u32 bpp, stride, offset;
1054cd98e85aSSteve Longerbeam u32 row_off, col_off;
1055cd98e85aSSteve Longerbeam
1056cd98e85aSSteve Longerbeam /* setup some convenience vars */
1057cd98e85aSSteve Longerbeam stride = image->stride;
1058cd98e85aSSteve Longerbeam bpp = fmt->bpp;
1059cd98e85aSSteve Longerbeam
1060cd98e85aSSteve Longerbeam for (row = 0; row < image->num_rows; row++) {
1061571dd82cSPhilipp Zabel row_off = image->tile[tile].top * stride;
1062cd98e85aSSteve Longerbeam
1063cd98e85aSSteve Longerbeam for (col = 0; col < image->num_cols; col++) {
1064571dd82cSPhilipp Zabel col_off = (image->tile[tile].left * bpp) >> 3;
1065cd98e85aSSteve Longerbeam
1066c4e45658SSteve Longerbeam offset = row_off + col_off;
1067c4e45658SSteve Longerbeam
1068c4e45658SSteve Longerbeam image->tile[tile].offset = offset;
1069cd98e85aSSteve Longerbeam image->tile[tile].u_off = 0;
1070cd98e85aSSteve Longerbeam image->tile[tile++].v_off = 0;
1071cd98e85aSSteve Longerbeam
1072c4e45658SSteve Longerbeam if (offset & 0x7) {
1073c4e45658SSteve Longerbeam dev_err(priv->ipu->dev,
1074c4e45658SSteve Longerbeam "task %u: ctx %p: %s@[%d,%d]: "
1075c4e45658SSteve Longerbeam "phys %08x\n",
1076cd98e85aSSteve Longerbeam chan->ic_task, ctx,
1077cd98e85aSSteve Longerbeam image->type == IMAGE_CONVERT_IN ?
1078cd98e85aSSteve Longerbeam "Input" : "Output", row, col,
1079cd98e85aSSteve Longerbeam row_off + col_off);
1080c4e45658SSteve Longerbeam return -EINVAL;
1081cd98e85aSSteve Longerbeam }
1082cd98e85aSSteve Longerbeam }
1083cd98e85aSSteve Longerbeam }
1084cd98e85aSSteve Longerbeam
1085c4e45658SSteve Longerbeam return 0;
1086c4e45658SSteve Longerbeam }
1087c4e45658SSteve Longerbeam
calc_tile_offsets(struct ipu_image_convert_ctx * ctx,struct ipu_image_convert_image * image)1088c4e45658SSteve Longerbeam static int calc_tile_offsets(struct ipu_image_convert_ctx *ctx,
1089cd98e85aSSteve Longerbeam struct ipu_image_convert_image *image)
1090cd98e85aSSteve Longerbeam {
1091cd98e85aSSteve Longerbeam if (image->fmt->planar)
1092c4e45658SSteve Longerbeam return calc_tile_offsets_planar(ctx, image);
1093c4e45658SSteve Longerbeam
1094c4e45658SSteve Longerbeam return calc_tile_offsets_packed(ctx, image);
1095cd98e85aSSteve Longerbeam }
1096cd98e85aSSteve Longerbeam
1097cd98e85aSSteve Longerbeam /*
109870b9b6b3SPhilipp Zabel * Calculate the resizing ratio for the IC main processing section given input
109970b9b6b3SPhilipp Zabel * size, fixed downsizing coefficient, and output size.
110070b9b6b3SPhilipp Zabel * Either round to closest for the next tile's first pixel to minimize seams
110170b9b6b3SPhilipp Zabel * and distortion (for all but right column / bottom row), or round down to
110270b9b6b3SPhilipp Zabel * avoid sampling beyond the edges of the input image for this tile's last
110370b9b6b3SPhilipp Zabel * pixel.
110470b9b6b3SPhilipp Zabel * Returns the resizing coefficient, resizing ratio is 8192.0 / resize_coeff.
110570b9b6b3SPhilipp Zabel */
calc_resize_coeff(u32 input_size,u32 downsize_coeff,u32 output_size,bool allow_overshoot)110670b9b6b3SPhilipp Zabel static u32 calc_resize_coeff(u32 input_size, u32 downsize_coeff,
110770b9b6b3SPhilipp Zabel u32 output_size, bool allow_overshoot)
110870b9b6b3SPhilipp Zabel {
110970b9b6b3SPhilipp Zabel u32 downsized = input_size >> downsize_coeff;
111070b9b6b3SPhilipp Zabel
111170b9b6b3SPhilipp Zabel if (allow_overshoot)
111270b9b6b3SPhilipp Zabel return DIV_ROUND_CLOSEST(8192 * downsized, output_size);
111370b9b6b3SPhilipp Zabel else
111470b9b6b3SPhilipp Zabel return 8192 * (downsized - 1) / (output_size - 1);
111570b9b6b3SPhilipp Zabel }
111670b9b6b3SPhilipp Zabel
111770b9b6b3SPhilipp Zabel /*
111870b9b6b3SPhilipp Zabel * Slightly modify resize coefficients per tile to hide the bilinear
111970b9b6b3SPhilipp Zabel * interpolator reset at tile borders, shifting the right / bottom edge
112070b9b6b3SPhilipp Zabel * by up to a half input pixel. This removes noticeable seams between
112170b9b6b3SPhilipp Zabel * tiles at higher upscaling factors.
112270b9b6b3SPhilipp Zabel */
calc_tile_resize_coefficients(struct ipu_image_convert_ctx * ctx)112370b9b6b3SPhilipp Zabel static void calc_tile_resize_coefficients(struct ipu_image_convert_ctx *ctx)
112470b9b6b3SPhilipp Zabel {
112570b9b6b3SPhilipp Zabel struct ipu_image_convert_chan *chan = ctx->chan;
112670b9b6b3SPhilipp Zabel struct ipu_image_convert_priv *priv = chan->priv;
112770b9b6b3SPhilipp Zabel struct ipu_image_tile *in_tile, *out_tile;
112870b9b6b3SPhilipp Zabel unsigned int col, row, tile_idx;
112970b9b6b3SPhilipp Zabel unsigned int last_output;
113070b9b6b3SPhilipp Zabel
113170b9b6b3SPhilipp Zabel for (col = 0; col < ctx->in.num_cols; col++) {
113270b9b6b3SPhilipp Zabel bool closest = (col < ctx->in.num_cols - 1) &&
113370b9b6b3SPhilipp Zabel !(ctx->rot_mode & IPU_ROT_BIT_HFLIP);
113470b9b6b3SPhilipp Zabel u32 resized_width;
113570b9b6b3SPhilipp Zabel u32 resize_coeff_h;
1136fbefb84dSPhilipp Zabel u32 in_width;
113770b9b6b3SPhilipp Zabel
113870b9b6b3SPhilipp Zabel tile_idx = col;
113970b9b6b3SPhilipp Zabel in_tile = &ctx->in.tile[tile_idx];
114070b9b6b3SPhilipp Zabel out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
114170b9b6b3SPhilipp Zabel
114270b9b6b3SPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode))
114370b9b6b3SPhilipp Zabel resized_width = out_tile->height;
114470b9b6b3SPhilipp Zabel else
114570b9b6b3SPhilipp Zabel resized_width = out_tile->width;
114670b9b6b3SPhilipp Zabel
114770b9b6b3SPhilipp Zabel resize_coeff_h = calc_resize_coeff(in_tile->width,
114870b9b6b3SPhilipp Zabel ctx->downsize_coeff_h,
114970b9b6b3SPhilipp Zabel resized_width, closest);
115070b9b6b3SPhilipp Zabel
115170b9b6b3SPhilipp Zabel dev_dbg(priv->ipu->dev, "%s: column %u hscale: *8192/%u\n",
115270b9b6b3SPhilipp Zabel __func__, col, resize_coeff_h);
115370b9b6b3SPhilipp Zabel
1154fbefb84dSPhilipp Zabel /*
1155fbefb84dSPhilipp Zabel * With the horizontal scaling factor known, round up resized
1156fbefb84dSPhilipp Zabel * width (output width or height) to burst size.
1157fbefb84dSPhilipp Zabel */
1158fbefb84dSPhilipp Zabel resized_width = round_up(resized_width, 8);
1159fbefb84dSPhilipp Zabel
1160fbefb84dSPhilipp Zabel /*
1161fbefb84dSPhilipp Zabel * Calculate input width from the last accessed input pixel
1162fbefb84dSPhilipp Zabel * given resized width and scaling coefficients. Round up to
1163fbefb84dSPhilipp Zabel * burst size.
1164fbefb84dSPhilipp Zabel */
1165fbefb84dSPhilipp Zabel last_output = resized_width - 1;
11664d243763SPhilipp Zabel if (closest && ((last_output * resize_coeff_h) % 8192))
1167fbefb84dSPhilipp Zabel last_output++;
1168fbefb84dSPhilipp Zabel in_width = round_up(
1169fbefb84dSPhilipp Zabel (DIV_ROUND_UP(last_output * resize_coeff_h, 8192) + 1)
1170fbefb84dSPhilipp Zabel << ctx->downsize_coeff_h, 8);
117170b9b6b3SPhilipp Zabel
117270b9b6b3SPhilipp Zabel for (row = 0; row < ctx->in.num_rows; row++) {
117370b9b6b3SPhilipp Zabel tile_idx = row * ctx->in.num_cols + col;
117470b9b6b3SPhilipp Zabel in_tile = &ctx->in.tile[tile_idx];
117570b9b6b3SPhilipp Zabel out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
117670b9b6b3SPhilipp Zabel
117770b9b6b3SPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode))
1178fbefb84dSPhilipp Zabel out_tile->height = resized_width;
117970b9b6b3SPhilipp Zabel else
1180fbefb84dSPhilipp Zabel out_tile->width = resized_width;
118170b9b6b3SPhilipp Zabel
1182fbefb84dSPhilipp Zabel in_tile->width = in_width;
118370b9b6b3SPhilipp Zabel }
118470b9b6b3SPhilipp Zabel
118570b9b6b3SPhilipp Zabel ctx->resize_coeffs_h[col] = resize_coeff_h;
118670b9b6b3SPhilipp Zabel }
118770b9b6b3SPhilipp Zabel
118870b9b6b3SPhilipp Zabel for (row = 0; row < ctx->in.num_rows; row++) {
118970b9b6b3SPhilipp Zabel bool closest = (row < ctx->in.num_rows - 1) &&
119070b9b6b3SPhilipp Zabel !(ctx->rot_mode & IPU_ROT_BIT_VFLIP);
119170b9b6b3SPhilipp Zabel u32 resized_height;
119270b9b6b3SPhilipp Zabel u32 resize_coeff_v;
1193fbefb84dSPhilipp Zabel u32 in_height;
119470b9b6b3SPhilipp Zabel
119570b9b6b3SPhilipp Zabel tile_idx = row * ctx->in.num_cols;
119670b9b6b3SPhilipp Zabel in_tile = &ctx->in.tile[tile_idx];
119770b9b6b3SPhilipp Zabel out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
119870b9b6b3SPhilipp Zabel
119970b9b6b3SPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode))
120070b9b6b3SPhilipp Zabel resized_height = out_tile->width;
120170b9b6b3SPhilipp Zabel else
120270b9b6b3SPhilipp Zabel resized_height = out_tile->height;
120370b9b6b3SPhilipp Zabel
120470b9b6b3SPhilipp Zabel resize_coeff_v = calc_resize_coeff(in_tile->height,
120570b9b6b3SPhilipp Zabel ctx->downsize_coeff_v,
120670b9b6b3SPhilipp Zabel resized_height, closest);
120770b9b6b3SPhilipp Zabel
120870b9b6b3SPhilipp Zabel dev_dbg(priv->ipu->dev, "%s: row %u vscale: *8192/%u\n",
120970b9b6b3SPhilipp Zabel __func__, row, resize_coeff_v);
121070b9b6b3SPhilipp Zabel
1211fbefb84dSPhilipp Zabel /*
1212fbefb84dSPhilipp Zabel * With the vertical scaling factor known, round up resized
1213fbefb84dSPhilipp Zabel * height (output width or height) to IDMAC limitations.
1214fbefb84dSPhilipp Zabel */
1215fbefb84dSPhilipp Zabel resized_height = round_up(resized_height, 2);
1216fbefb84dSPhilipp Zabel
1217fbefb84dSPhilipp Zabel /*
1218fbefb84dSPhilipp Zabel * Calculate input width from the last accessed input pixel
1219fbefb84dSPhilipp Zabel * given resized height and scaling coefficients. Align to
1220fbefb84dSPhilipp Zabel * IDMAC restrictions.
1221fbefb84dSPhilipp Zabel */
1222fbefb84dSPhilipp Zabel last_output = resized_height - 1;
12234d243763SPhilipp Zabel if (closest && ((last_output * resize_coeff_v) % 8192))
1224fbefb84dSPhilipp Zabel last_output++;
1225fbefb84dSPhilipp Zabel in_height = round_up(
1226fbefb84dSPhilipp Zabel (DIV_ROUND_UP(last_output * resize_coeff_v, 8192) + 1)
1227fbefb84dSPhilipp Zabel << ctx->downsize_coeff_v, 2);
1228fbefb84dSPhilipp Zabel
122970b9b6b3SPhilipp Zabel for (col = 0; col < ctx->in.num_cols; col++) {
123070b9b6b3SPhilipp Zabel tile_idx = row * ctx->in.num_cols + col;
123170b9b6b3SPhilipp Zabel in_tile = &ctx->in.tile[tile_idx];
123270b9b6b3SPhilipp Zabel out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
123370b9b6b3SPhilipp Zabel
123470b9b6b3SPhilipp Zabel if (ipu_rot_mode_is_irt(ctx->rot_mode))
1235fbefb84dSPhilipp Zabel out_tile->width = resized_height;
123670b9b6b3SPhilipp Zabel else
1237fbefb84dSPhilipp Zabel out_tile->height = resized_height;
123870b9b6b3SPhilipp Zabel
1239fbefb84dSPhilipp Zabel in_tile->height = in_height;
124070b9b6b3SPhilipp Zabel }
124170b9b6b3SPhilipp Zabel
124270b9b6b3SPhilipp Zabel ctx->resize_coeffs_v[row] = resize_coeff_v;
124370b9b6b3SPhilipp Zabel }
124470b9b6b3SPhilipp Zabel }
124570b9b6b3SPhilipp Zabel
124670b9b6b3SPhilipp Zabel /*
1247cd98e85aSSteve Longerbeam * return the number of runs in given queue (pending_q or done_q)
1248cd98e85aSSteve Longerbeam * for this context. hold irqlock when calling.
1249cd98e85aSSteve Longerbeam */
get_run_count(struct ipu_image_convert_ctx * ctx,struct list_head * q)1250cd98e85aSSteve Longerbeam static int get_run_count(struct ipu_image_convert_ctx *ctx,
1251cd98e85aSSteve Longerbeam struct list_head *q)
1252cd98e85aSSteve Longerbeam {
1253cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run;
1254cd98e85aSSteve Longerbeam int count = 0;
1255cd98e85aSSteve Longerbeam
1256cd98e85aSSteve Longerbeam lockdep_assert_held(&ctx->chan->irqlock);
1257cd98e85aSSteve Longerbeam
1258cd98e85aSSteve Longerbeam list_for_each_entry(run, q, list) {
1259cd98e85aSSteve Longerbeam if (run->ctx == ctx)
1260cd98e85aSSteve Longerbeam count++;
1261cd98e85aSSteve Longerbeam }
1262cd98e85aSSteve Longerbeam
1263cd98e85aSSteve Longerbeam return count;
1264cd98e85aSSteve Longerbeam }
1265cd98e85aSSteve Longerbeam
convert_stop(struct ipu_image_convert_run * run)1266cd98e85aSSteve Longerbeam static void convert_stop(struct ipu_image_convert_run *run)
1267cd98e85aSSteve Longerbeam {
1268cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx = run->ctx;
1269cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
1270cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1271cd98e85aSSteve Longerbeam
1272cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev, "%s: task %u: stopping ctx %p run %p\n",
1273cd98e85aSSteve Longerbeam __func__, chan->ic_task, ctx, run);
1274cd98e85aSSteve Longerbeam
1275cd98e85aSSteve Longerbeam /* disable IC tasks and the channels */
1276cd98e85aSSteve Longerbeam ipu_ic_task_disable(chan->ic);
1277cd98e85aSSteve Longerbeam ipu_idmac_disable_channel(chan->in_chan);
1278cd98e85aSSteve Longerbeam ipu_idmac_disable_channel(chan->out_chan);
1279cd98e85aSSteve Longerbeam
1280cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
1281cd98e85aSSteve Longerbeam ipu_idmac_disable_channel(chan->rotation_in_chan);
1282cd98e85aSSteve Longerbeam ipu_idmac_disable_channel(chan->rotation_out_chan);
1283cd98e85aSSteve Longerbeam ipu_idmac_unlink(chan->out_chan, chan->rotation_in_chan);
1284cd98e85aSSteve Longerbeam }
1285cd98e85aSSteve Longerbeam
1286cd98e85aSSteve Longerbeam ipu_ic_disable(chan->ic);
1287cd98e85aSSteve Longerbeam }
1288cd98e85aSSteve Longerbeam
init_idmac_channel(struct ipu_image_convert_ctx * ctx,struct ipuv3_channel * channel,struct ipu_image_convert_image * image,enum ipu_rotate_mode rot_mode,bool rot_swap_width_height,unsigned int tile)1289cd98e85aSSteve Longerbeam static void init_idmac_channel(struct ipu_image_convert_ctx *ctx,
1290cd98e85aSSteve Longerbeam struct ipuv3_channel *channel,
1291cd98e85aSSteve Longerbeam struct ipu_image_convert_image *image,
1292cd98e85aSSteve Longerbeam enum ipu_rotate_mode rot_mode,
1293dd65d2a9SPhilipp Zabel bool rot_swap_width_height,
1294dd65d2a9SPhilipp Zabel unsigned int tile)
1295cd98e85aSSteve Longerbeam {
1296cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
1297cd98e85aSSteve Longerbeam unsigned int burst_size;
1298cd98e85aSSteve Longerbeam u32 width, height, stride;
1299cd98e85aSSteve Longerbeam dma_addr_t addr0, addr1 = 0;
1300cd98e85aSSteve Longerbeam struct ipu_image tile_image;
1301cd98e85aSSteve Longerbeam unsigned int tile_idx[2];
1302cd98e85aSSteve Longerbeam
1303cd98e85aSSteve Longerbeam if (image->type == IMAGE_CONVERT_OUT) {
1304dd65d2a9SPhilipp Zabel tile_idx[0] = ctx->out_tile_map[tile];
1305cd98e85aSSteve Longerbeam tile_idx[1] = ctx->out_tile_map[1];
1306cd98e85aSSteve Longerbeam } else {
1307dd65d2a9SPhilipp Zabel tile_idx[0] = tile;
1308cd98e85aSSteve Longerbeam tile_idx[1] = 1;
1309cd98e85aSSteve Longerbeam }
1310cd98e85aSSteve Longerbeam
1311cd98e85aSSteve Longerbeam if (rot_swap_width_height) {
1312dd65d2a9SPhilipp Zabel width = image->tile[tile_idx[0]].height;
1313dd65d2a9SPhilipp Zabel height = image->tile[tile_idx[0]].width;
1314dd65d2a9SPhilipp Zabel stride = image->tile[tile_idx[0]].rot_stride;
1315cd98e85aSSteve Longerbeam addr0 = ctx->rot_intermediate[0].phys;
1316cd98e85aSSteve Longerbeam if (ctx->double_buffering)
1317cd98e85aSSteve Longerbeam addr1 = ctx->rot_intermediate[1].phys;
1318cd98e85aSSteve Longerbeam } else {
1319dd65d2a9SPhilipp Zabel width = image->tile[tile_idx[0]].width;
1320dd65d2a9SPhilipp Zabel height = image->tile[tile_idx[0]].height;
1321cd98e85aSSteve Longerbeam stride = image->stride;
1322cd98e85aSSteve Longerbeam addr0 = image->base.phys0 +
1323cd98e85aSSteve Longerbeam image->tile[tile_idx[0]].offset;
1324cd98e85aSSteve Longerbeam if (ctx->double_buffering)
1325cd98e85aSSteve Longerbeam addr1 = image->base.phys0 +
1326cd98e85aSSteve Longerbeam image->tile[tile_idx[1]].offset;
1327cd98e85aSSteve Longerbeam }
1328cd98e85aSSteve Longerbeam
1329cd98e85aSSteve Longerbeam ipu_cpmem_zero(channel);
1330cd98e85aSSteve Longerbeam
1331cd98e85aSSteve Longerbeam memset(&tile_image, 0, sizeof(tile_image));
1332cd98e85aSSteve Longerbeam tile_image.pix.width = tile_image.rect.width = width;
1333cd98e85aSSteve Longerbeam tile_image.pix.height = tile_image.rect.height = height;
1334cd98e85aSSteve Longerbeam tile_image.pix.bytesperline = stride;
1335cd98e85aSSteve Longerbeam tile_image.pix.pixelformat = image->fmt->fourcc;
1336cd98e85aSSteve Longerbeam tile_image.phys0 = addr0;
1337cd98e85aSSteve Longerbeam tile_image.phys1 = addr1;
1338dec408fdSSteve Longerbeam if (image->fmt->planar && !rot_swap_width_height) {
1339dec408fdSSteve Longerbeam tile_image.u_offset = image->tile[tile_idx[0]].u_off;
1340dec408fdSSteve Longerbeam tile_image.v_offset = image->tile[tile_idx[0]].v_off;
1341dec408fdSSteve Longerbeam }
1342cd98e85aSSteve Longerbeam
1343dec408fdSSteve Longerbeam ipu_cpmem_set_image(channel, &tile_image);
1344cd98e85aSSteve Longerbeam
1345cd98e85aSSteve Longerbeam if (rot_mode)
1346cd98e85aSSteve Longerbeam ipu_cpmem_set_rotation(channel, rot_mode);
1347cd98e85aSSteve Longerbeam
1348fee77829SSteve Longerbeam /*
1349fee77829SSteve Longerbeam * Skip writing U and V components to odd rows in the output
1350fee77829SSteve Longerbeam * channels for planar 4:2:0.
1351fee77829SSteve Longerbeam */
1352fee77829SSteve Longerbeam if ((channel == chan->out_chan ||
1353fee77829SSteve Longerbeam channel == chan->rotation_out_chan) &&
1354fee77829SSteve Longerbeam image->fmt->planar && image->fmt->uv_height_dec == 2)
1355fee77829SSteve Longerbeam ipu_cpmem_skip_odd_chroma_rows(channel);
1356fee77829SSteve Longerbeam
1357cd98e85aSSteve Longerbeam if (channel == chan->rotation_in_chan ||
1358cd98e85aSSteve Longerbeam channel == chan->rotation_out_chan) {
1359cd98e85aSSteve Longerbeam burst_size = 8;
1360cd98e85aSSteve Longerbeam ipu_cpmem_set_block_mode(channel);
1361cd98e85aSSteve Longerbeam } else
1362cd98e85aSSteve Longerbeam burst_size = (width % 16) ? 8 : 16;
1363cd98e85aSSteve Longerbeam
1364cd98e85aSSteve Longerbeam ipu_cpmem_set_burstsize(channel, burst_size);
1365cd98e85aSSteve Longerbeam
1366cd98e85aSSteve Longerbeam ipu_ic_task_idma_init(chan->ic, channel, width, height,
1367cd98e85aSSteve Longerbeam burst_size, rot_mode);
1368cd98e85aSSteve Longerbeam
1369320a89adSLucas Stach /*
1370320a89adSLucas Stach * Setting a non-zero AXI ID collides with the PRG AXI snooping, so
1371320a89adSLucas Stach * only do this when there is no PRG present.
1372320a89adSLucas Stach */
1373320a89adSLucas Stach if (!channel->ipu->prg_priv)
1374cd98e85aSSteve Longerbeam ipu_cpmem_set_axi_id(channel, 1);
1375cd98e85aSSteve Longerbeam
1376cd98e85aSSteve Longerbeam ipu_idmac_set_double_buffer(channel, ctx->double_buffering);
1377cd98e85aSSteve Longerbeam }
1378cd98e85aSSteve Longerbeam
convert_start(struct ipu_image_convert_run * run,unsigned int tile)1379dd65d2a9SPhilipp Zabel static int convert_start(struct ipu_image_convert_run *run, unsigned int tile)
1380cd98e85aSSteve Longerbeam {
1381cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx = run->ctx;
1382cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
1383cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1384cd98e85aSSteve Longerbeam struct ipu_image_convert_image *s_image = &ctx->in;
1385cd98e85aSSteve Longerbeam struct ipu_image_convert_image *d_image = &ctx->out;
1386dd65d2a9SPhilipp Zabel unsigned int dst_tile = ctx->out_tile_map[tile];
1387cd98e85aSSteve Longerbeam unsigned int dest_width, dest_height;
138870b9b6b3SPhilipp Zabel unsigned int col, row;
138970b9b6b3SPhilipp Zabel u32 rsc;
1390cd98e85aSSteve Longerbeam int ret;
1391cd98e85aSSteve Longerbeam
1392dd65d2a9SPhilipp Zabel dev_dbg(priv->ipu->dev, "%s: task %u: starting ctx %p run %p tile %u -> %u\n",
1393dd65d2a9SPhilipp Zabel __func__, chan->ic_task, ctx, run, tile, dst_tile);
1394cd98e85aSSteve Longerbeam
1395dd81d821SSteve Longerbeam /* clear EOF irq mask */
1396dd81d821SSteve Longerbeam ctx->eof_mask = 0;
1397dd81d821SSteve Longerbeam
1398cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
1399cd98e85aSSteve Longerbeam /* swap width/height for resizer */
1400dd65d2a9SPhilipp Zabel dest_width = d_image->tile[dst_tile].height;
1401dd65d2a9SPhilipp Zabel dest_height = d_image->tile[dst_tile].width;
1402cd98e85aSSteve Longerbeam } else {
1403dd65d2a9SPhilipp Zabel dest_width = d_image->tile[dst_tile].width;
1404dd65d2a9SPhilipp Zabel dest_height = d_image->tile[dst_tile].height;
1405cd98e85aSSteve Longerbeam }
1406cd98e85aSSteve Longerbeam
140770b9b6b3SPhilipp Zabel row = tile / s_image->num_cols;
140870b9b6b3SPhilipp Zabel col = tile % s_image->num_cols;
140970b9b6b3SPhilipp Zabel
141070b9b6b3SPhilipp Zabel rsc = (ctx->downsize_coeff_v << 30) |
141170b9b6b3SPhilipp Zabel (ctx->resize_coeffs_v[row] << 16) |
141270b9b6b3SPhilipp Zabel (ctx->downsize_coeff_h << 14) |
141370b9b6b3SPhilipp Zabel (ctx->resize_coeffs_h[col]);
141470b9b6b3SPhilipp Zabel
141570b9b6b3SPhilipp Zabel dev_dbg(priv->ipu->dev, "%s: %ux%u -> %ux%u (rsc = 0x%x)\n",
141670b9b6b3SPhilipp Zabel __func__, s_image->tile[tile].width,
141770b9b6b3SPhilipp Zabel s_image->tile[tile].height, dest_width, dest_height, rsc);
141870b9b6b3SPhilipp Zabel
1419cd98e85aSSteve Longerbeam /* setup the IC resizer and CSC */
1420f208b26eSSteve Longerbeam ret = ipu_ic_task_init_rsc(chan->ic, &ctx->csc,
1421dd65d2a9SPhilipp Zabel s_image->tile[tile].width,
1422dd65d2a9SPhilipp Zabel s_image->tile[tile].height,
1423cd98e85aSSteve Longerbeam dest_width,
1424cd98e85aSSteve Longerbeam dest_height,
142570b9b6b3SPhilipp Zabel rsc);
1426cd98e85aSSteve Longerbeam if (ret) {
1427cd98e85aSSteve Longerbeam dev_err(priv->ipu->dev, "ipu_ic_task_init failed, %d\n", ret);
1428cd98e85aSSteve Longerbeam return ret;
1429cd98e85aSSteve Longerbeam }
1430cd98e85aSSteve Longerbeam
1431cd98e85aSSteve Longerbeam /* init the source MEM-->IC PP IDMAC channel */
1432cd98e85aSSteve Longerbeam init_idmac_channel(ctx, chan->in_chan, s_image,
1433dd65d2a9SPhilipp Zabel IPU_ROTATE_NONE, false, tile);
1434cd98e85aSSteve Longerbeam
1435cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
1436cd98e85aSSteve Longerbeam /* init the IC PP-->MEM IDMAC channel */
1437cd98e85aSSteve Longerbeam init_idmac_channel(ctx, chan->out_chan, d_image,
1438dd65d2a9SPhilipp Zabel IPU_ROTATE_NONE, true, tile);
1439cd98e85aSSteve Longerbeam
1440cd98e85aSSteve Longerbeam /* init the MEM-->IC PP ROT IDMAC channel */
1441cd98e85aSSteve Longerbeam init_idmac_channel(ctx, chan->rotation_in_chan, d_image,
1442dd65d2a9SPhilipp Zabel ctx->rot_mode, true, tile);
1443cd98e85aSSteve Longerbeam
1444cd98e85aSSteve Longerbeam /* init the destination IC PP ROT-->MEM IDMAC channel */
1445cd98e85aSSteve Longerbeam init_idmac_channel(ctx, chan->rotation_out_chan, d_image,
1446dd65d2a9SPhilipp Zabel IPU_ROTATE_NONE, false, tile);
1447cd98e85aSSteve Longerbeam
1448cd98e85aSSteve Longerbeam /* now link IC PP-->MEM to MEM-->IC PP ROT */
1449cd98e85aSSteve Longerbeam ipu_idmac_link(chan->out_chan, chan->rotation_in_chan);
1450cd98e85aSSteve Longerbeam } else {
1451cd98e85aSSteve Longerbeam /* init the destination IC PP-->MEM IDMAC channel */
1452cd98e85aSSteve Longerbeam init_idmac_channel(ctx, chan->out_chan, d_image,
1453dd65d2a9SPhilipp Zabel ctx->rot_mode, false, tile);
1454cd98e85aSSteve Longerbeam }
1455cd98e85aSSteve Longerbeam
1456cd98e85aSSteve Longerbeam /* enable the IC */
1457cd98e85aSSteve Longerbeam ipu_ic_enable(chan->ic);
1458cd98e85aSSteve Longerbeam
1459cd98e85aSSteve Longerbeam /* set buffers ready */
1460cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->in_chan, 0);
1461cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->out_chan, 0);
1462cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode))
1463cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->rotation_out_chan, 0);
1464cd98e85aSSteve Longerbeam if (ctx->double_buffering) {
1465cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->in_chan, 1);
1466cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->out_chan, 1);
1467cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode))
1468cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->rotation_out_chan, 1);
1469cd98e85aSSteve Longerbeam }
1470cd98e85aSSteve Longerbeam
1471cd98e85aSSteve Longerbeam /* enable the channels! */
1472cd98e85aSSteve Longerbeam ipu_idmac_enable_channel(chan->in_chan);
1473cd98e85aSSteve Longerbeam ipu_idmac_enable_channel(chan->out_chan);
1474cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
1475cd98e85aSSteve Longerbeam ipu_idmac_enable_channel(chan->rotation_in_chan);
1476cd98e85aSSteve Longerbeam ipu_idmac_enable_channel(chan->rotation_out_chan);
1477cd98e85aSSteve Longerbeam }
1478cd98e85aSSteve Longerbeam
1479cd98e85aSSteve Longerbeam ipu_ic_task_enable(chan->ic);
1480cd98e85aSSteve Longerbeam
1481cd98e85aSSteve Longerbeam ipu_cpmem_dump(chan->in_chan);
1482cd98e85aSSteve Longerbeam ipu_cpmem_dump(chan->out_chan);
1483cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
1484cd98e85aSSteve Longerbeam ipu_cpmem_dump(chan->rotation_in_chan);
1485cd98e85aSSteve Longerbeam ipu_cpmem_dump(chan->rotation_out_chan);
1486cd98e85aSSteve Longerbeam }
1487cd98e85aSSteve Longerbeam
1488cd98e85aSSteve Longerbeam ipu_dump(priv->ipu);
1489cd98e85aSSteve Longerbeam
1490cd98e85aSSteve Longerbeam return 0;
1491cd98e85aSSteve Longerbeam }
1492cd98e85aSSteve Longerbeam
1493cd98e85aSSteve Longerbeam /* hold irqlock when calling */
do_run(struct ipu_image_convert_run * run)1494cd98e85aSSteve Longerbeam static int do_run(struct ipu_image_convert_run *run)
1495cd98e85aSSteve Longerbeam {
1496cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx = run->ctx;
1497cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
1498cd98e85aSSteve Longerbeam
1499cd98e85aSSteve Longerbeam lockdep_assert_held(&chan->irqlock);
1500cd98e85aSSteve Longerbeam
1501cd98e85aSSteve Longerbeam ctx->in.base.phys0 = run->in_phys;
1502cd98e85aSSteve Longerbeam ctx->out.base.phys0 = run->out_phys;
1503cd98e85aSSteve Longerbeam
1504cd98e85aSSteve Longerbeam ctx->cur_buf_num = 0;
1505cd98e85aSSteve Longerbeam ctx->next_tile = 1;
1506cd98e85aSSteve Longerbeam
1507cd98e85aSSteve Longerbeam /* remove run from pending_q and set as current */
1508cd98e85aSSteve Longerbeam list_del(&run->list);
1509cd98e85aSSteve Longerbeam chan->current_run = run;
1510cd98e85aSSteve Longerbeam
1511dd65d2a9SPhilipp Zabel return convert_start(run, 0);
1512cd98e85aSSteve Longerbeam }
1513cd98e85aSSteve Longerbeam
1514cd98e85aSSteve Longerbeam /* hold irqlock when calling */
run_next(struct ipu_image_convert_chan * chan)1515cd98e85aSSteve Longerbeam static void run_next(struct ipu_image_convert_chan *chan)
1516cd98e85aSSteve Longerbeam {
1517cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1518cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run, *tmp;
1519cd98e85aSSteve Longerbeam int ret;
1520cd98e85aSSteve Longerbeam
1521cd98e85aSSteve Longerbeam lockdep_assert_held(&chan->irqlock);
1522cd98e85aSSteve Longerbeam
1523cd98e85aSSteve Longerbeam list_for_each_entry_safe(run, tmp, &chan->pending_q, list) {
1524cd98e85aSSteve Longerbeam /* skip contexts that are aborting */
1525cd98e85aSSteve Longerbeam if (run->ctx->aborting) {
1526cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev,
1527cd98e85aSSteve Longerbeam "%s: task %u: skipping aborting ctx %p run %p\n",
1528cd98e85aSSteve Longerbeam __func__, chan->ic_task, run->ctx, run);
1529cd98e85aSSteve Longerbeam continue;
1530cd98e85aSSteve Longerbeam }
1531cd98e85aSSteve Longerbeam
1532cd98e85aSSteve Longerbeam ret = do_run(run);
1533cd98e85aSSteve Longerbeam if (!ret)
1534cd98e85aSSteve Longerbeam break;
1535cd98e85aSSteve Longerbeam
1536cd98e85aSSteve Longerbeam /*
1537cd98e85aSSteve Longerbeam * something went wrong with start, add the run
1538cd98e85aSSteve Longerbeam * to done q and continue to the next run in the
1539cd98e85aSSteve Longerbeam * pending q.
1540cd98e85aSSteve Longerbeam */
1541cd98e85aSSteve Longerbeam run->status = ret;
1542cd98e85aSSteve Longerbeam list_add_tail(&run->list, &chan->done_q);
1543cd98e85aSSteve Longerbeam chan->current_run = NULL;
1544cd98e85aSSteve Longerbeam }
1545cd98e85aSSteve Longerbeam }
1546cd98e85aSSteve Longerbeam
empty_done_q(struct ipu_image_convert_chan * chan)1547cd98e85aSSteve Longerbeam static void empty_done_q(struct ipu_image_convert_chan *chan)
1548cd98e85aSSteve Longerbeam {
1549cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1550cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run;
1551cd98e85aSSteve Longerbeam unsigned long flags;
1552cd98e85aSSteve Longerbeam
1553cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
1554cd98e85aSSteve Longerbeam
1555cd98e85aSSteve Longerbeam while (!list_empty(&chan->done_q)) {
1556cd98e85aSSteve Longerbeam run = list_entry(chan->done_q.next,
1557cd98e85aSSteve Longerbeam struct ipu_image_convert_run,
1558cd98e85aSSteve Longerbeam list);
1559cd98e85aSSteve Longerbeam
1560cd98e85aSSteve Longerbeam list_del(&run->list);
1561cd98e85aSSteve Longerbeam
1562cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev,
1563cd98e85aSSteve Longerbeam "%s: task %u: completing ctx %p run %p with %d\n",
1564cd98e85aSSteve Longerbeam __func__, chan->ic_task, run->ctx, run, run->status);
1565cd98e85aSSteve Longerbeam
1566cd98e85aSSteve Longerbeam /* call the completion callback and free the run */
1567cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
1568cd98e85aSSteve Longerbeam run->ctx->complete(run, run->ctx->complete_context);
1569cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
1570cd98e85aSSteve Longerbeam }
1571cd98e85aSSteve Longerbeam
1572cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
1573cd98e85aSSteve Longerbeam }
1574cd98e85aSSteve Longerbeam
1575cd98e85aSSteve Longerbeam /*
1576cd98e85aSSteve Longerbeam * the bottom half thread clears out the done_q, calling the
1577cd98e85aSSteve Longerbeam * completion handler for each.
1578cd98e85aSSteve Longerbeam */
do_bh(int irq,void * dev_id)1579cd98e85aSSteve Longerbeam static irqreturn_t do_bh(int irq, void *dev_id)
1580cd98e85aSSteve Longerbeam {
1581cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = dev_id;
1582cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1583cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx;
1584cd98e85aSSteve Longerbeam unsigned long flags;
1585cd98e85aSSteve Longerbeam
1586cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev, "%s: task %u: enter\n", __func__,
1587cd98e85aSSteve Longerbeam chan->ic_task);
1588cd98e85aSSteve Longerbeam
1589cd98e85aSSteve Longerbeam empty_done_q(chan);
1590cd98e85aSSteve Longerbeam
1591cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
1592cd98e85aSSteve Longerbeam
1593cd98e85aSSteve Longerbeam /*
1594cd98e85aSSteve Longerbeam * the done_q is cleared out, signal any contexts
1595cd98e85aSSteve Longerbeam * that are aborting that abort can complete.
1596cd98e85aSSteve Longerbeam */
1597cd98e85aSSteve Longerbeam list_for_each_entry(ctx, &chan->ctx_list, list) {
1598cd98e85aSSteve Longerbeam if (ctx->aborting) {
1599cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev,
1600cd98e85aSSteve Longerbeam "%s: task %u: signaling abort for ctx %p\n",
1601cd98e85aSSteve Longerbeam __func__, chan->ic_task, ctx);
1602aa60b261SSteve Longerbeam complete_all(&ctx->aborted);
1603cd98e85aSSteve Longerbeam }
1604cd98e85aSSteve Longerbeam }
1605cd98e85aSSteve Longerbeam
1606cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
1607cd98e85aSSteve Longerbeam
1608cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev, "%s: task %u: exit\n", __func__,
1609cd98e85aSSteve Longerbeam chan->ic_task);
1610cd98e85aSSteve Longerbeam
1611cd98e85aSSteve Longerbeam return IRQ_HANDLED;
1612cd98e85aSSteve Longerbeam }
1613cd98e85aSSteve Longerbeam
ic_settings_changed(struct ipu_image_convert_ctx * ctx)16140537db80SPhilipp Zabel static bool ic_settings_changed(struct ipu_image_convert_ctx *ctx)
16150537db80SPhilipp Zabel {
16160537db80SPhilipp Zabel unsigned int cur_tile = ctx->next_tile - 1;
16170537db80SPhilipp Zabel unsigned int next_tile = ctx->next_tile;
16180537db80SPhilipp Zabel
16190537db80SPhilipp Zabel if (ctx->resize_coeffs_h[cur_tile % ctx->in.num_cols] !=
16200537db80SPhilipp Zabel ctx->resize_coeffs_h[next_tile % ctx->in.num_cols] ||
16210537db80SPhilipp Zabel ctx->resize_coeffs_v[cur_tile / ctx->in.num_cols] !=
16220537db80SPhilipp Zabel ctx->resize_coeffs_v[next_tile / ctx->in.num_cols] ||
16230537db80SPhilipp Zabel ctx->in.tile[cur_tile].width != ctx->in.tile[next_tile].width ||
16240537db80SPhilipp Zabel ctx->in.tile[cur_tile].height != ctx->in.tile[next_tile].height ||
16250537db80SPhilipp Zabel ctx->out.tile[cur_tile].width != ctx->out.tile[next_tile].width ||
16260537db80SPhilipp Zabel ctx->out.tile[cur_tile].height != ctx->out.tile[next_tile].height)
16270537db80SPhilipp Zabel return true;
16280537db80SPhilipp Zabel
16290537db80SPhilipp Zabel return false;
16300537db80SPhilipp Zabel }
16310537db80SPhilipp Zabel
1632cd98e85aSSteve Longerbeam /* hold irqlock when calling */
do_tile_complete(struct ipu_image_convert_run * run)1633dd81d821SSteve Longerbeam static irqreturn_t do_tile_complete(struct ipu_image_convert_run *run)
1634cd98e85aSSteve Longerbeam {
1635cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx = run->ctx;
1636cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
1637cd98e85aSSteve Longerbeam struct ipu_image_tile *src_tile, *dst_tile;
1638cd98e85aSSteve Longerbeam struct ipu_image_convert_image *s_image = &ctx->in;
1639cd98e85aSSteve Longerbeam struct ipu_image_convert_image *d_image = &ctx->out;
1640cd98e85aSSteve Longerbeam struct ipuv3_channel *outch;
1641cd98e85aSSteve Longerbeam unsigned int dst_idx;
1642cd98e85aSSteve Longerbeam
1643cd98e85aSSteve Longerbeam lockdep_assert_held(&chan->irqlock);
1644cd98e85aSSteve Longerbeam
1645cd98e85aSSteve Longerbeam outch = ipu_rot_mode_is_irt(ctx->rot_mode) ?
1646cd98e85aSSteve Longerbeam chan->rotation_out_chan : chan->out_chan;
1647cd98e85aSSteve Longerbeam
1648cd98e85aSSteve Longerbeam /*
1649cd98e85aSSteve Longerbeam * It is difficult to stop the channel DMA before the channels
1650cd98e85aSSteve Longerbeam * enter the paused state. Without double-buffering the channels
1651cd98e85aSSteve Longerbeam * are always in a paused state when the EOF irq occurs, so it
1652cd98e85aSSteve Longerbeam * is safe to stop the channels now. For double-buffering we
1653cd98e85aSSteve Longerbeam * just ignore the abort until the operation completes, when it
1654cd98e85aSSteve Longerbeam * is safe to shut down.
1655cd98e85aSSteve Longerbeam */
1656cd98e85aSSteve Longerbeam if (ctx->aborting && !ctx->double_buffering) {
1657cd98e85aSSteve Longerbeam convert_stop(run);
1658cd98e85aSSteve Longerbeam run->status = -EIO;
1659cd98e85aSSteve Longerbeam goto done;
1660cd98e85aSSteve Longerbeam }
1661cd98e85aSSteve Longerbeam
1662cd98e85aSSteve Longerbeam if (ctx->next_tile == ctx->num_tiles) {
1663cd98e85aSSteve Longerbeam /*
1664cd98e85aSSteve Longerbeam * the conversion is complete
1665cd98e85aSSteve Longerbeam */
1666cd98e85aSSteve Longerbeam convert_stop(run);
1667cd98e85aSSteve Longerbeam run->status = 0;
1668cd98e85aSSteve Longerbeam goto done;
1669cd98e85aSSteve Longerbeam }
1670cd98e85aSSteve Longerbeam
1671cd98e85aSSteve Longerbeam /*
1672cd98e85aSSteve Longerbeam * not done, place the next tile buffers.
1673cd98e85aSSteve Longerbeam */
1674cd98e85aSSteve Longerbeam if (!ctx->double_buffering) {
16750537db80SPhilipp Zabel if (ic_settings_changed(ctx)) {
16760537db80SPhilipp Zabel convert_stop(run);
16770537db80SPhilipp Zabel convert_start(run, ctx->next_tile);
16780537db80SPhilipp Zabel } else {
1679cd98e85aSSteve Longerbeam src_tile = &s_image->tile[ctx->next_tile];
1680cd98e85aSSteve Longerbeam dst_idx = ctx->out_tile_map[ctx->next_tile];
1681cd98e85aSSteve Longerbeam dst_tile = &d_image->tile[dst_idx];
1682cd98e85aSSteve Longerbeam
1683cd98e85aSSteve Longerbeam ipu_cpmem_set_buffer(chan->in_chan, 0,
16840537db80SPhilipp Zabel s_image->base.phys0 +
16850537db80SPhilipp Zabel src_tile->offset);
1686cd98e85aSSteve Longerbeam ipu_cpmem_set_buffer(outch, 0,
16870537db80SPhilipp Zabel d_image->base.phys0 +
16880537db80SPhilipp Zabel dst_tile->offset);
1689cd98e85aSSteve Longerbeam if (s_image->fmt->planar)
1690cd98e85aSSteve Longerbeam ipu_cpmem_set_uv_offset(chan->in_chan,
1691cd98e85aSSteve Longerbeam src_tile->u_off,
1692cd98e85aSSteve Longerbeam src_tile->v_off);
1693cd98e85aSSteve Longerbeam if (d_image->fmt->planar)
1694cd98e85aSSteve Longerbeam ipu_cpmem_set_uv_offset(outch,
1695cd98e85aSSteve Longerbeam dst_tile->u_off,
1696cd98e85aSSteve Longerbeam dst_tile->v_off);
1697cd98e85aSSteve Longerbeam
1698cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->in_chan, 0);
1699cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(outch, 0);
17000537db80SPhilipp Zabel }
1701cd98e85aSSteve Longerbeam } else if (ctx->next_tile < ctx->num_tiles - 1) {
1702cd98e85aSSteve Longerbeam
1703cd98e85aSSteve Longerbeam src_tile = &s_image->tile[ctx->next_tile + 1];
1704cd98e85aSSteve Longerbeam dst_idx = ctx->out_tile_map[ctx->next_tile + 1];
1705cd98e85aSSteve Longerbeam dst_tile = &d_image->tile[dst_idx];
1706cd98e85aSSteve Longerbeam
1707cd98e85aSSteve Longerbeam ipu_cpmem_set_buffer(chan->in_chan, ctx->cur_buf_num,
1708cd98e85aSSteve Longerbeam s_image->base.phys0 + src_tile->offset);
1709cd98e85aSSteve Longerbeam ipu_cpmem_set_buffer(outch, ctx->cur_buf_num,
1710cd98e85aSSteve Longerbeam d_image->base.phys0 + dst_tile->offset);
1711cd98e85aSSteve Longerbeam
1712cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(chan->in_chan, ctx->cur_buf_num);
1713cd98e85aSSteve Longerbeam ipu_idmac_select_buffer(outch, ctx->cur_buf_num);
1714cd98e85aSSteve Longerbeam
1715cd98e85aSSteve Longerbeam ctx->cur_buf_num ^= 1;
1716cd98e85aSSteve Longerbeam }
1717cd98e85aSSteve Longerbeam
1718dd81d821SSteve Longerbeam ctx->eof_mask = 0; /* clear EOF irq mask for next tile */
1719cd98e85aSSteve Longerbeam ctx->next_tile++;
1720cd98e85aSSteve Longerbeam return IRQ_HANDLED;
1721cd98e85aSSteve Longerbeam done:
1722cd98e85aSSteve Longerbeam list_add_tail(&run->list, &chan->done_q);
1723cd98e85aSSteve Longerbeam chan->current_run = NULL;
1724cd98e85aSSteve Longerbeam run_next(chan);
1725cd98e85aSSteve Longerbeam return IRQ_WAKE_THREAD;
1726cd98e85aSSteve Longerbeam }
1727cd98e85aSSteve Longerbeam
eof_irq(int irq,void * data)17280f6245f4SSteve Longerbeam static irqreturn_t eof_irq(int irq, void *data)
1729cd98e85aSSteve Longerbeam {
1730cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = data;
1731cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1732cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx;
1733cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run;
1734dd81d821SSteve Longerbeam irqreturn_t ret = IRQ_HANDLED;
1735dd81d821SSteve Longerbeam bool tile_complete = false;
1736cd98e85aSSteve Longerbeam unsigned long flags;
1737cd98e85aSSteve Longerbeam
1738cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
1739cd98e85aSSteve Longerbeam
1740cd98e85aSSteve Longerbeam /* get current run and its context */
1741cd98e85aSSteve Longerbeam run = chan->current_run;
1742cd98e85aSSteve Longerbeam if (!run) {
1743cd98e85aSSteve Longerbeam ret = IRQ_NONE;
1744cd98e85aSSteve Longerbeam goto out;
1745cd98e85aSSteve Longerbeam }
1746cd98e85aSSteve Longerbeam
1747cd98e85aSSteve Longerbeam ctx = run->ctx;
1748cd98e85aSSteve Longerbeam
1749dd81d821SSteve Longerbeam if (irq == chan->in_eof_irq) {
1750dd81d821SSteve Longerbeam ctx->eof_mask |= EOF_IRQ_IN;
1751dd81d821SSteve Longerbeam } else if (irq == chan->out_eof_irq) {
1752dd81d821SSteve Longerbeam ctx->eof_mask |= EOF_IRQ_OUT;
1753dd81d821SSteve Longerbeam } else if (irq == chan->rot_in_eof_irq ||
1754dd81d821SSteve Longerbeam irq == chan->rot_out_eof_irq) {
1755cd98e85aSSteve Longerbeam if (!ipu_rot_mode_is_irt(ctx->rot_mode)) {
17560f6245f4SSteve Longerbeam /* this was NOT a rotation op, shouldn't happen */
17570f6245f4SSteve Longerbeam dev_err(priv->ipu->dev,
17580f6245f4SSteve Longerbeam "Unexpected rotation interrupt\n");
17590f6245f4SSteve Longerbeam goto out;
17600f6245f4SSteve Longerbeam }
1761dd81d821SSteve Longerbeam ctx->eof_mask |= (irq == chan->rot_in_eof_irq) ?
1762dd81d821SSteve Longerbeam EOF_IRQ_ROT_IN : EOF_IRQ_ROT_OUT;
17630f6245f4SSteve Longerbeam } else {
17640f6245f4SSteve Longerbeam dev_err(priv->ipu->dev, "Received unknown irq %d\n", irq);
17650f6245f4SSteve Longerbeam ret = IRQ_NONE;
17660f6245f4SSteve Longerbeam goto out;
1767cd98e85aSSteve Longerbeam }
1768cd98e85aSSteve Longerbeam
1769dd81d821SSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode))
1770dd81d821SSteve Longerbeam tile_complete = (ctx->eof_mask == EOF_IRQ_ROT_COMPLETE);
1771dd81d821SSteve Longerbeam else
1772dd81d821SSteve Longerbeam tile_complete = (ctx->eof_mask == EOF_IRQ_COMPLETE);
1773dd81d821SSteve Longerbeam
1774dd81d821SSteve Longerbeam if (tile_complete)
1775dd81d821SSteve Longerbeam ret = do_tile_complete(run);
1776cd98e85aSSteve Longerbeam out:
1777cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
1778cd98e85aSSteve Longerbeam return ret;
1779cd98e85aSSteve Longerbeam }
1780cd98e85aSSteve Longerbeam
1781cd98e85aSSteve Longerbeam /*
1782cd98e85aSSteve Longerbeam * try to force the completion of runs for this ctx. Called when
1783cd98e85aSSteve Longerbeam * abort wait times out in ipu_image_convert_abort().
1784cd98e85aSSteve Longerbeam */
force_abort(struct ipu_image_convert_ctx * ctx)1785cd98e85aSSteve Longerbeam static void force_abort(struct ipu_image_convert_ctx *ctx)
1786cd98e85aSSteve Longerbeam {
1787cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
1788cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run;
1789cd98e85aSSteve Longerbeam unsigned long flags;
1790cd98e85aSSteve Longerbeam
1791cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
1792cd98e85aSSteve Longerbeam
1793cd98e85aSSteve Longerbeam run = chan->current_run;
1794cd98e85aSSteve Longerbeam if (run && run->ctx == ctx) {
1795cd98e85aSSteve Longerbeam convert_stop(run);
1796cd98e85aSSteve Longerbeam run->status = -EIO;
1797cd98e85aSSteve Longerbeam list_add_tail(&run->list, &chan->done_q);
1798cd98e85aSSteve Longerbeam chan->current_run = NULL;
1799cd98e85aSSteve Longerbeam run_next(chan);
1800cd98e85aSSteve Longerbeam }
1801cd98e85aSSteve Longerbeam
1802cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
1803cd98e85aSSteve Longerbeam
1804cd98e85aSSteve Longerbeam empty_done_q(chan);
1805cd98e85aSSteve Longerbeam }
1806cd98e85aSSteve Longerbeam
release_ipu_resources(struct ipu_image_convert_chan * chan)1807cd98e85aSSteve Longerbeam static void release_ipu_resources(struct ipu_image_convert_chan *chan)
1808cd98e85aSSteve Longerbeam {
1809dd81d821SSteve Longerbeam if (chan->in_eof_irq >= 0)
1810dd81d821SSteve Longerbeam free_irq(chan->in_eof_irq, chan);
1811dd81d821SSteve Longerbeam if (chan->rot_in_eof_irq >= 0)
1812dd81d821SSteve Longerbeam free_irq(chan->rot_in_eof_irq, chan);
1813cd98e85aSSteve Longerbeam if (chan->out_eof_irq >= 0)
1814cd98e85aSSteve Longerbeam free_irq(chan->out_eof_irq, chan);
1815cd98e85aSSteve Longerbeam if (chan->rot_out_eof_irq >= 0)
1816cd98e85aSSteve Longerbeam free_irq(chan->rot_out_eof_irq, chan);
1817cd98e85aSSteve Longerbeam
1818cd98e85aSSteve Longerbeam if (!IS_ERR_OR_NULL(chan->in_chan))
1819cd98e85aSSteve Longerbeam ipu_idmac_put(chan->in_chan);
1820cd98e85aSSteve Longerbeam if (!IS_ERR_OR_NULL(chan->out_chan))
1821cd98e85aSSteve Longerbeam ipu_idmac_put(chan->out_chan);
1822cd98e85aSSteve Longerbeam if (!IS_ERR_OR_NULL(chan->rotation_in_chan))
1823cd98e85aSSteve Longerbeam ipu_idmac_put(chan->rotation_in_chan);
1824cd98e85aSSteve Longerbeam if (!IS_ERR_OR_NULL(chan->rotation_out_chan))
1825cd98e85aSSteve Longerbeam ipu_idmac_put(chan->rotation_out_chan);
1826cd98e85aSSteve Longerbeam if (!IS_ERR_OR_NULL(chan->ic))
1827cd98e85aSSteve Longerbeam ipu_ic_put(chan->ic);
1828cd98e85aSSteve Longerbeam
1829cd98e85aSSteve Longerbeam chan->in_chan = chan->out_chan = chan->rotation_in_chan =
1830cd98e85aSSteve Longerbeam chan->rotation_out_chan = NULL;
1831dd81d821SSteve Longerbeam chan->in_eof_irq = -1;
1832dd81d821SSteve Longerbeam chan->rot_in_eof_irq = -1;
1833dd81d821SSteve Longerbeam chan->out_eof_irq = -1;
1834dd81d821SSteve Longerbeam chan->rot_out_eof_irq = -1;
1835dd81d821SSteve Longerbeam }
1836dd81d821SSteve Longerbeam
get_eof_irq(struct ipu_image_convert_chan * chan,struct ipuv3_channel * channel)1837dd81d821SSteve Longerbeam static int get_eof_irq(struct ipu_image_convert_chan *chan,
1838dd81d821SSteve Longerbeam struct ipuv3_channel *channel)
1839dd81d821SSteve Longerbeam {
1840dd81d821SSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1841dd81d821SSteve Longerbeam int ret, irq;
1842dd81d821SSteve Longerbeam
1843dd81d821SSteve Longerbeam irq = ipu_idmac_channel_irq(priv->ipu, channel, IPU_IRQ_EOF);
1844dd81d821SSteve Longerbeam
1845dd81d821SSteve Longerbeam ret = request_threaded_irq(irq, eof_irq, do_bh, 0, "ipu-ic", chan);
1846dd81d821SSteve Longerbeam if (ret < 0) {
1847dd81d821SSteve Longerbeam dev_err(priv->ipu->dev, "could not acquire irq %d\n", irq);
1848dd81d821SSteve Longerbeam return ret;
1849dd81d821SSteve Longerbeam }
1850dd81d821SSteve Longerbeam
1851dd81d821SSteve Longerbeam return irq;
1852cd98e85aSSteve Longerbeam }
1853cd98e85aSSteve Longerbeam
get_ipu_resources(struct ipu_image_convert_chan * chan)1854cd98e85aSSteve Longerbeam static int get_ipu_resources(struct ipu_image_convert_chan *chan)
1855cd98e85aSSteve Longerbeam {
1856cd98e85aSSteve Longerbeam const struct ipu_image_convert_dma_chan *dma = chan->dma_ch;
1857cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
1858cd98e85aSSteve Longerbeam int ret;
1859cd98e85aSSteve Longerbeam
1860cd98e85aSSteve Longerbeam /* get IC */
1861cd98e85aSSteve Longerbeam chan->ic = ipu_ic_get(priv->ipu, chan->ic_task);
1862cd98e85aSSteve Longerbeam if (IS_ERR(chan->ic)) {
1863cd98e85aSSteve Longerbeam dev_err(priv->ipu->dev, "could not acquire IC\n");
1864cd98e85aSSteve Longerbeam ret = PTR_ERR(chan->ic);
1865cd98e85aSSteve Longerbeam goto err;
1866cd98e85aSSteve Longerbeam }
1867cd98e85aSSteve Longerbeam
1868cd98e85aSSteve Longerbeam /* get IDMAC channels */
1869cd98e85aSSteve Longerbeam chan->in_chan = ipu_idmac_get(priv->ipu, dma->in);
1870cd98e85aSSteve Longerbeam chan->out_chan = ipu_idmac_get(priv->ipu, dma->out);
1871cd98e85aSSteve Longerbeam if (IS_ERR(chan->in_chan) || IS_ERR(chan->out_chan)) {
1872cd98e85aSSteve Longerbeam dev_err(priv->ipu->dev, "could not acquire idmac channels\n");
1873cd98e85aSSteve Longerbeam ret = -EBUSY;
1874cd98e85aSSteve Longerbeam goto err;
1875cd98e85aSSteve Longerbeam }
1876cd98e85aSSteve Longerbeam
1877cd98e85aSSteve Longerbeam chan->rotation_in_chan = ipu_idmac_get(priv->ipu, dma->rot_in);
1878cd98e85aSSteve Longerbeam chan->rotation_out_chan = ipu_idmac_get(priv->ipu, dma->rot_out);
1879cd98e85aSSteve Longerbeam if (IS_ERR(chan->rotation_in_chan) || IS_ERR(chan->rotation_out_chan)) {
1880cd98e85aSSteve Longerbeam dev_err(priv->ipu->dev,
1881cd98e85aSSteve Longerbeam "could not acquire idmac rotation channels\n");
1882cd98e85aSSteve Longerbeam ret = -EBUSY;
1883cd98e85aSSteve Longerbeam goto err;
1884cd98e85aSSteve Longerbeam }
1885cd98e85aSSteve Longerbeam
1886cd98e85aSSteve Longerbeam /* acquire the EOF interrupts */
1887dd81d821SSteve Longerbeam ret = get_eof_irq(chan, chan->in_chan);
1888cd98e85aSSteve Longerbeam if (ret < 0) {
1889dd81d821SSteve Longerbeam chan->in_eof_irq = -1;
1890dd81d821SSteve Longerbeam goto err;
1891dd81d821SSteve Longerbeam }
1892dd81d821SSteve Longerbeam chan->in_eof_irq = ret;
1893dd81d821SSteve Longerbeam
1894dd81d821SSteve Longerbeam ret = get_eof_irq(chan, chan->rotation_in_chan);
1895dd81d821SSteve Longerbeam if (ret < 0) {
1896dd81d821SSteve Longerbeam chan->rot_in_eof_irq = -1;
1897dd81d821SSteve Longerbeam goto err;
1898dd81d821SSteve Longerbeam }
1899dd81d821SSteve Longerbeam chan->rot_in_eof_irq = ret;
1900dd81d821SSteve Longerbeam
1901dd81d821SSteve Longerbeam ret = get_eof_irq(chan, chan->out_chan);
1902dd81d821SSteve Longerbeam if (ret < 0) {
1903cd98e85aSSteve Longerbeam chan->out_eof_irq = -1;
1904cd98e85aSSteve Longerbeam goto err;
1905cd98e85aSSteve Longerbeam }
1906dd81d821SSteve Longerbeam chan->out_eof_irq = ret;
1907cd98e85aSSteve Longerbeam
1908dd81d821SSteve Longerbeam ret = get_eof_irq(chan, chan->rotation_out_chan);
1909cd98e85aSSteve Longerbeam if (ret < 0) {
1910cd98e85aSSteve Longerbeam chan->rot_out_eof_irq = -1;
1911cd98e85aSSteve Longerbeam goto err;
1912cd98e85aSSteve Longerbeam }
1913dd81d821SSteve Longerbeam chan->rot_out_eof_irq = ret;
1914cd98e85aSSteve Longerbeam
1915cd98e85aSSteve Longerbeam return 0;
1916cd98e85aSSteve Longerbeam err:
1917cd98e85aSSteve Longerbeam release_ipu_resources(chan);
1918cd98e85aSSteve Longerbeam return ret;
1919cd98e85aSSteve Longerbeam }
1920cd98e85aSSteve Longerbeam
fill_image(struct ipu_image_convert_ctx * ctx,struct ipu_image_convert_image * ic_image,struct ipu_image * image,enum ipu_image_convert_type type)1921cd98e85aSSteve Longerbeam static int fill_image(struct ipu_image_convert_ctx *ctx,
1922cd98e85aSSteve Longerbeam struct ipu_image_convert_image *ic_image,
1923cd98e85aSSteve Longerbeam struct ipu_image *image,
1924cd98e85aSSteve Longerbeam enum ipu_image_convert_type type)
1925cd98e85aSSteve Longerbeam {
1926cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = ctx->chan->priv;
1927cd98e85aSSteve Longerbeam
1928cd98e85aSSteve Longerbeam ic_image->base = *image;
1929cd98e85aSSteve Longerbeam ic_image->type = type;
1930cd98e85aSSteve Longerbeam
1931cd98e85aSSteve Longerbeam ic_image->fmt = get_format(image->pix.pixelformat);
1932cd98e85aSSteve Longerbeam if (!ic_image->fmt) {
1933cd98e85aSSteve Longerbeam dev_err(priv->ipu->dev, "pixelformat not supported for %s\n",
1934cd98e85aSSteve Longerbeam type == IMAGE_CONVERT_OUT ? "Output" : "Input");
1935cd98e85aSSteve Longerbeam return -EINVAL;
1936cd98e85aSSteve Longerbeam }
1937cd98e85aSSteve Longerbeam
1938cd98e85aSSteve Longerbeam if (ic_image->fmt->planar)
1939cd98e85aSSteve Longerbeam ic_image->stride = ic_image->base.pix.width;
1940cd98e85aSSteve Longerbeam else
1941cd98e85aSSteve Longerbeam ic_image->stride = ic_image->base.pix.bytesperline;
1942cd98e85aSSteve Longerbeam
194326ddd032SPhilipp Zabel return 0;
1944cd98e85aSSteve Longerbeam }
1945cd98e85aSSteve Longerbeam
1946cd98e85aSSteve Longerbeam /* borrowed from drivers/media/v4l2-core/v4l2-common.c */
clamp_align(unsigned int x,unsigned int min,unsigned int max,unsigned int align)1947cd98e85aSSteve Longerbeam static unsigned int clamp_align(unsigned int x, unsigned int min,
1948cd98e85aSSteve Longerbeam unsigned int max, unsigned int align)
1949cd98e85aSSteve Longerbeam {
1950cd98e85aSSteve Longerbeam /* Bits that must be zero to be aligned */
1951cd98e85aSSteve Longerbeam unsigned int mask = ~((1 << align) - 1);
1952cd98e85aSSteve Longerbeam
1953cd98e85aSSteve Longerbeam /* Clamp to aligned min and max */
1954cd98e85aSSteve Longerbeam x = clamp(x, (min + ~mask) & mask, max & mask);
1955cd98e85aSSteve Longerbeam
1956cd98e85aSSteve Longerbeam /* Round to nearest aligned value */
1957cd98e85aSSteve Longerbeam if (align)
1958cd98e85aSSteve Longerbeam x = (x + (1 << (align - 1))) & mask;
1959cd98e85aSSteve Longerbeam
1960cd98e85aSSteve Longerbeam return x;
1961cd98e85aSSteve Longerbeam }
1962cd98e85aSSteve Longerbeam
1963cd98e85aSSteve Longerbeam /* Adjusts input/output images to IPU restrictions */
ipu_image_convert_adjust(struct ipu_image * in,struct ipu_image * out,enum ipu_rotate_mode rot_mode)1964cd98e85aSSteve Longerbeam void ipu_image_convert_adjust(struct ipu_image *in, struct ipu_image *out,
1965cd98e85aSSteve Longerbeam enum ipu_rotate_mode rot_mode)
1966cd98e85aSSteve Longerbeam {
1967cd98e85aSSteve Longerbeam const struct ipu_image_pixfmt *infmt, *outfmt;
1968ff391ecdSSteve Longerbeam u32 w_align_out, h_align_out;
1969ff391ecdSSteve Longerbeam u32 w_align_in, h_align_in;
1970cd98e85aSSteve Longerbeam
1971cd98e85aSSteve Longerbeam infmt = get_format(in->pix.pixelformat);
1972cd98e85aSSteve Longerbeam outfmt = get_format(out->pix.pixelformat);
1973cd98e85aSSteve Longerbeam
1974cd98e85aSSteve Longerbeam /* set some default pixel formats if needed */
1975cd98e85aSSteve Longerbeam if (!infmt) {
1976cd98e85aSSteve Longerbeam in->pix.pixelformat = V4L2_PIX_FMT_RGB24;
1977cd98e85aSSteve Longerbeam infmt = get_format(V4L2_PIX_FMT_RGB24);
1978cd98e85aSSteve Longerbeam }
1979cd98e85aSSteve Longerbeam if (!outfmt) {
1980cd98e85aSSteve Longerbeam out->pix.pixelformat = V4L2_PIX_FMT_RGB24;
1981cd98e85aSSteve Longerbeam outfmt = get_format(V4L2_PIX_FMT_RGB24);
1982cd98e85aSSteve Longerbeam }
1983cd98e85aSSteve Longerbeam
1984cd98e85aSSteve Longerbeam /* image converter does not handle fields */
1985cd98e85aSSteve Longerbeam in->pix.field = out->pix.field = V4L2_FIELD_NONE;
1986cd98e85aSSteve Longerbeam
1987cd98e85aSSteve Longerbeam /* resizer cannot downsize more than 4:1 */
1988cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(rot_mode)) {
1989cd98e85aSSteve Longerbeam out->pix.height = max_t(__u32, out->pix.height,
1990cd98e85aSSteve Longerbeam in->pix.width / 4);
1991cd98e85aSSteve Longerbeam out->pix.width = max_t(__u32, out->pix.width,
1992cd98e85aSSteve Longerbeam in->pix.height / 4);
1993cd98e85aSSteve Longerbeam } else {
1994cd98e85aSSteve Longerbeam out->pix.width = max_t(__u32, out->pix.width,
1995cd98e85aSSteve Longerbeam in->pix.width / 4);
1996cd98e85aSSteve Longerbeam out->pix.height = max_t(__u32, out->pix.height,
1997cd98e85aSSteve Longerbeam in->pix.height / 4);
1998cd98e85aSSteve Longerbeam }
1999cd98e85aSSteve Longerbeam
2000cd98e85aSSteve Longerbeam /* align input width/height */
2001ff391ecdSSteve Longerbeam w_align_in = ilog2(tile_width_align(IMAGE_CONVERT_IN, infmt,
2002ff391ecdSSteve Longerbeam rot_mode));
2003ff391ecdSSteve Longerbeam h_align_in = ilog2(tile_height_align(IMAGE_CONVERT_IN, infmt,
2004ff391ecdSSteve Longerbeam rot_mode));
2005ff391ecdSSteve Longerbeam in->pix.width = clamp_align(in->pix.width, MIN_W, MAX_W,
2006ff391ecdSSteve Longerbeam w_align_in);
2007ff391ecdSSteve Longerbeam in->pix.height = clamp_align(in->pix.height, MIN_H, MAX_H,
2008ff391ecdSSteve Longerbeam h_align_in);
2009cd98e85aSSteve Longerbeam
2010cd98e85aSSteve Longerbeam /* align output width/height */
2011ff391ecdSSteve Longerbeam w_align_out = ilog2(tile_width_align(IMAGE_CONVERT_OUT, outfmt,
2012ff391ecdSSteve Longerbeam rot_mode));
2013ff391ecdSSteve Longerbeam h_align_out = ilog2(tile_height_align(IMAGE_CONVERT_OUT, outfmt,
2014ff391ecdSSteve Longerbeam rot_mode));
2015ff391ecdSSteve Longerbeam out->pix.width = clamp_align(out->pix.width, MIN_W, MAX_W,
2016ff391ecdSSteve Longerbeam w_align_out);
2017ff391ecdSSteve Longerbeam out->pix.height = clamp_align(out->pix.height, MIN_H, MAX_H,
2018ff391ecdSSteve Longerbeam h_align_out);
2019cd98e85aSSteve Longerbeam
2020cd98e85aSSteve Longerbeam /* set input/output strides and image sizes */
2021d966e23dSPhilipp Zabel in->pix.bytesperline = infmt->planar ?
2022ff391ecdSSteve Longerbeam clamp_align(in->pix.width, 2 << w_align_in, MAX_W,
2023ff391ecdSSteve Longerbeam w_align_in) :
2024d966e23dSPhilipp Zabel clamp_align((in->pix.width * infmt->bpp) >> 3,
2025bca4d70cSSteve Longerbeam ((2 << w_align_in) * infmt->bpp) >> 3,
2026bca4d70cSSteve Longerbeam (MAX_W * infmt->bpp) >> 3,
2027bca4d70cSSteve Longerbeam w_align_in);
2028d966e23dSPhilipp Zabel in->pix.sizeimage = infmt->planar ?
2029d966e23dSPhilipp Zabel (in->pix.height * in->pix.bytesperline * infmt->bpp) >> 3 :
2030d966e23dSPhilipp Zabel in->pix.height * in->pix.bytesperline;
2031d966e23dSPhilipp Zabel out->pix.bytesperline = outfmt->planar ? out->pix.width :
2032d966e23dSPhilipp Zabel (out->pix.width * outfmt->bpp) >> 3;
2033d966e23dSPhilipp Zabel out->pix.sizeimage = outfmt->planar ?
2034d966e23dSPhilipp Zabel (out->pix.height * out->pix.bytesperline * outfmt->bpp) >> 3 :
2035d966e23dSPhilipp Zabel out->pix.height * out->pix.bytesperline;
2036cd98e85aSSteve Longerbeam }
2037cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_adjust);
2038cd98e85aSSteve Longerbeam
2039cd98e85aSSteve Longerbeam /*
2040cd98e85aSSteve Longerbeam * this is used by ipu_image_convert_prepare() to verify set input and
2041cd98e85aSSteve Longerbeam * output images are valid before starting the conversion. Clients can
2042cd98e85aSSteve Longerbeam * also call it before calling ipu_image_convert_prepare().
2043cd98e85aSSteve Longerbeam */
ipu_image_convert_verify(struct ipu_image * in,struct ipu_image * out,enum ipu_rotate_mode rot_mode)2044cd98e85aSSteve Longerbeam int ipu_image_convert_verify(struct ipu_image *in, struct ipu_image *out,
2045cd98e85aSSteve Longerbeam enum ipu_rotate_mode rot_mode)
2046cd98e85aSSteve Longerbeam {
2047cd98e85aSSteve Longerbeam struct ipu_image testin, testout;
2048cd98e85aSSteve Longerbeam
2049cd98e85aSSteve Longerbeam testin = *in;
2050cd98e85aSSteve Longerbeam testout = *out;
2051cd98e85aSSteve Longerbeam
2052cd98e85aSSteve Longerbeam ipu_image_convert_adjust(&testin, &testout, rot_mode);
2053cd98e85aSSteve Longerbeam
2054cd98e85aSSteve Longerbeam if (testin.pix.width != in->pix.width ||
2055cd98e85aSSteve Longerbeam testin.pix.height != in->pix.height ||
2056cd98e85aSSteve Longerbeam testout.pix.width != out->pix.width ||
2057cd98e85aSSteve Longerbeam testout.pix.height != out->pix.height)
2058cd98e85aSSteve Longerbeam return -EINVAL;
2059cd98e85aSSteve Longerbeam
2060cd98e85aSSteve Longerbeam return 0;
2061cd98e85aSSteve Longerbeam }
2062cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_verify);
2063cd98e85aSSteve Longerbeam
2064cd98e85aSSteve Longerbeam /*
2065cd98e85aSSteve Longerbeam * Call ipu_image_convert_prepare() to prepare for the conversion of
2066cd98e85aSSteve Longerbeam * given images and rotation mode. Returns a new conversion context.
2067cd98e85aSSteve Longerbeam */
2068cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *
ipu_image_convert_prepare(struct ipu_soc * ipu,enum ipu_ic_task ic_task,struct ipu_image * in,struct ipu_image * out,enum ipu_rotate_mode rot_mode,ipu_image_convert_cb_t complete,void * complete_context)2069cd98e85aSSteve Longerbeam ipu_image_convert_prepare(struct ipu_soc *ipu, enum ipu_ic_task ic_task,
2070cd98e85aSSteve Longerbeam struct ipu_image *in, struct ipu_image *out,
2071cd98e85aSSteve Longerbeam enum ipu_rotate_mode rot_mode,
2072cd98e85aSSteve Longerbeam ipu_image_convert_cb_t complete,
2073cd98e85aSSteve Longerbeam void *complete_context)
2074cd98e85aSSteve Longerbeam {
2075cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = ipu->image_convert_priv;
2076cd98e85aSSteve Longerbeam struct ipu_image_convert_image *s_image, *d_image;
2077cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan;
2078cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx;
2079cd98e85aSSteve Longerbeam unsigned long flags;
2080f1ef14f3SPhilipp Zabel unsigned int i;
2081cd98e85aSSteve Longerbeam bool get_res;
2082cd98e85aSSteve Longerbeam int ret;
2083cd98e85aSSteve Longerbeam
2084cd98e85aSSteve Longerbeam if (!in || !out || !complete ||
2085cd98e85aSSteve Longerbeam (ic_task != IC_TASK_VIEWFINDER &&
2086cd98e85aSSteve Longerbeam ic_task != IC_TASK_POST_PROCESSOR))
2087cd98e85aSSteve Longerbeam return ERR_PTR(-EINVAL);
2088cd98e85aSSteve Longerbeam
2089cd98e85aSSteve Longerbeam /* verify the in/out images before continuing */
2090cd98e85aSSteve Longerbeam ret = ipu_image_convert_verify(in, out, rot_mode);
2091cd98e85aSSteve Longerbeam if (ret) {
2092cd98e85aSSteve Longerbeam dev_err(priv->ipu->dev, "%s: in/out formats invalid\n",
2093cd98e85aSSteve Longerbeam __func__);
2094cd98e85aSSteve Longerbeam return ERR_PTR(ret);
2095cd98e85aSSteve Longerbeam }
2096cd98e85aSSteve Longerbeam
2097cd98e85aSSteve Longerbeam chan = &priv->chan[ic_task];
2098cd98e85aSSteve Longerbeam
2099cd98e85aSSteve Longerbeam ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
2100cd98e85aSSteve Longerbeam if (!ctx)
2101cd98e85aSSteve Longerbeam return ERR_PTR(-ENOMEM);
2102cd98e85aSSteve Longerbeam
2103cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev, "%s: task %u: ctx %p\n", __func__,
2104cd98e85aSSteve Longerbeam chan->ic_task, ctx);
2105cd98e85aSSteve Longerbeam
2106cd98e85aSSteve Longerbeam ctx->chan = chan;
2107cd98e85aSSteve Longerbeam init_completion(&ctx->aborted);
2108cd98e85aSSteve Longerbeam
2109de2564c7SPhilipp Zabel ctx->rot_mode = rot_mode;
2110de2564c7SPhilipp Zabel
2111de2564c7SPhilipp Zabel /* Sets ctx->in.num_rows/cols as well */
2112de2564c7SPhilipp Zabel ret = calc_image_resize_coefficients(ctx, in, out);
2113de2564c7SPhilipp Zabel if (ret)
2114de2564c7SPhilipp Zabel goto out_free;
2115de2564c7SPhilipp Zabel
2116cd98e85aSSteve Longerbeam s_image = &ctx->in;
2117cd98e85aSSteve Longerbeam d_image = &ctx->out;
2118cd98e85aSSteve Longerbeam
2119cd98e85aSSteve Longerbeam /* set tiling and rotation */
2120cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(rot_mode)) {
2121de2564c7SPhilipp Zabel d_image->num_rows = s_image->num_cols;
2122de2564c7SPhilipp Zabel d_image->num_cols = s_image->num_rows;
2123cd98e85aSSteve Longerbeam } else {
2124de2564c7SPhilipp Zabel d_image->num_rows = s_image->num_rows;
2125de2564c7SPhilipp Zabel d_image->num_cols = s_image->num_cols;
2126cd98e85aSSteve Longerbeam }
2127cd98e85aSSteve Longerbeam
2128cd98e85aSSteve Longerbeam ctx->num_tiles = d_image->num_cols * d_image->num_rows;
2129cd98e85aSSteve Longerbeam
2130cd98e85aSSteve Longerbeam ret = fill_image(ctx, s_image, in, IMAGE_CONVERT_IN);
2131cd98e85aSSteve Longerbeam if (ret)
2132cd98e85aSSteve Longerbeam goto out_free;
2133cd98e85aSSteve Longerbeam ret = fill_image(ctx, d_image, out, IMAGE_CONVERT_OUT);
2134cd98e85aSSteve Longerbeam if (ret)
2135cd98e85aSSteve Longerbeam goto out_free;
2136cd98e85aSSteve Longerbeam
213764fbae5eSPhilipp Zabel calc_out_tile_map(ctx);
213864fbae5eSPhilipp Zabel
213964fbae5eSPhilipp Zabel find_seams(ctx, s_image, d_image);
214064fbae5eSPhilipp Zabel
21415fb8b650SPhilipp Zabel ret = calc_tile_dimensions(ctx, s_image);
21425fb8b650SPhilipp Zabel if (ret)
21435fb8b650SPhilipp Zabel goto out_free;
21445fb8b650SPhilipp Zabel
214526ddd032SPhilipp Zabel ret = calc_tile_offsets(ctx, s_image);
214626ddd032SPhilipp Zabel if (ret)
214726ddd032SPhilipp Zabel goto out_free;
214826ddd032SPhilipp Zabel
214926ddd032SPhilipp Zabel calc_tile_dimensions(ctx, d_image);
215026ddd032SPhilipp Zabel ret = calc_tile_offsets(ctx, d_image);
215126ddd032SPhilipp Zabel if (ret)
215226ddd032SPhilipp Zabel goto out_free;
215326ddd032SPhilipp Zabel
215470b9b6b3SPhilipp Zabel calc_tile_resize_coefficients(ctx);
2155cd98e85aSSteve Longerbeam
2156f208b26eSSteve Longerbeam ret = ipu_ic_calc_csc(&ctx->csc,
2157f208b26eSSteve Longerbeam s_image->base.pix.ycbcr_enc,
2158f208b26eSSteve Longerbeam s_image->base.pix.quantization,
2159f208b26eSSteve Longerbeam ipu_pixelformat_to_colorspace(s_image->fmt->fourcc),
2160f208b26eSSteve Longerbeam d_image->base.pix.ycbcr_enc,
2161f208b26eSSteve Longerbeam d_image->base.pix.quantization,
2162f208b26eSSteve Longerbeam ipu_pixelformat_to_colorspace(d_image->fmt->fourcc));
2163f208b26eSSteve Longerbeam if (ret)
2164f208b26eSSteve Longerbeam goto out_free;
2165f208b26eSSteve Longerbeam
2166cd98e85aSSteve Longerbeam dump_format(ctx, s_image);
2167cd98e85aSSteve Longerbeam dump_format(ctx, d_image);
2168cd98e85aSSteve Longerbeam
2169cd98e85aSSteve Longerbeam ctx->complete = complete;
2170cd98e85aSSteve Longerbeam ctx->complete_context = complete_context;
2171cd98e85aSSteve Longerbeam
2172cd98e85aSSteve Longerbeam /*
2173cd98e85aSSteve Longerbeam * Can we use double-buffering for this operation? If there is
2174cd98e85aSSteve Longerbeam * only one tile (the whole image can be converted in a single
2175cd98e85aSSteve Longerbeam * operation) there's no point in using double-buffering. Also,
2176cd98e85aSSteve Longerbeam * the IPU's IDMAC channels allow only a single U and V plane
2177cd98e85aSSteve Longerbeam * offset shared between both buffers, but these offsets change
2178cd98e85aSSteve Longerbeam * for every tile, and therefore would have to be updated for
2179cd98e85aSSteve Longerbeam * each buffer which is not possible. So double-buffering is
2180cd98e85aSSteve Longerbeam * impossible when either the source or destination images are
2181f1ef14f3SPhilipp Zabel * a planar format (YUV420, YUV422P, etc.). Further, differently
2182f1ef14f3SPhilipp Zabel * sized tiles or different resizing coefficients per tile
2183f1ef14f3SPhilipp Zabel * prevent double-buffering as well.
2184cd98e85aSSteve Longerbeam */
2185cd98e85aSSteve Longerbeam ctx->double_buffering = (ctx->num_tiles > 1 &&
2186cd98e85aSSteve Longerbeam !s_image->fmt->planar &&
2187cd98e85aSSteve Longerbeam !d_image->fmt->planar);
2188f1ef14f3SPhilipp Zabel for (i = 1; i < ctx->num_tiles; i++) {
2189f1ef14f3SPhilipp Zabel if (ctx->in.tile[i].width != ctx->in.tile[0].width ||
2190f1ef14f3SPhilipp Zabel ctx->in.tile[i].height != ctx->in.tile[0].height ||
2191f1ef14f3SPhilipp Zabel ctx->out.tile[i].width != ctx->out.tile[0].width ||
2192f1ef14f3SPhilipp Zabel ctx->out.tile[i].height != ctx->out.tile[0].height) {
2193f1ef14f3SPhilipp Zabel ctx->double_buffering = false;
2194f1ef14f3SPhilipp Zabel break;
2195f1ef14f3SPhilipp Zabel }
2196f1ef14f3SPhilipp Zabel }
2197f1ef14f3SPhilipp Zabel for (i = 1; i < ctx->in.num_cols; i++) {
2198f1ef14f3SPhilipp Zabel if (ctx->resize_coeffs_h[i] != ctx->resize_coeffs_h[0]) {
2199f1ef14f3SPhilipp Zabel ctx->double_buffering = false;
2200f1ef14f3SPhilipp Zabel break;
2201f1ef14f3SPhilipp Zabel }
2202f1ef14f3SPhilipp Zabel }
2203f1ef14f3SPhilipp Zabel for (i = 1; i < ctx->in.num_rows; i++) {
2204f1ef14f3SPhilipp Zabel if (ctx->resize_coeffs_v[i] != ctx->resize_coeffs_v[0]) {
2205f1ef14f3SPhilipp Zabel ctx->double_buffering = false;
2206f1ef14f3SPhilipp Zabel break;
2207f1ef14f3SPhilipp Zabel }
2208f1ef14f3SPhilipp Zabel }
2209cd98e85aSSteve Longerbeam
2210cd98e85aSSteve Longerbeam if (ipu_rot_mode_is_irt(ctx->rot_mode)) {
2211dd65d2a9SPhilipp Zabel unsigned long intermediate_size = d_image->tile[0].size;
2212dd65d2a9SPhilipp Zabel
2213dd65d2a9SPhilipp Zabel for (i = 1; i < ctx->num_tiles; i++) {
2214dd65d2a9SPhilipp Zabel if (d_image->tile[i].size > intermediate_size)
2215dd65d2a9SPhilipp Zabel intermediate_size = d_image->tile[i].size;
2216dd65d2a9SPhilipp Zabel }
2217dd65d2a9SPhilipp Zabel
2218cd98e85aSSteve Longerbeam ret = alloc_dma_buf(priv, &ctx->rot_intermediate[0],
2219dd65d2a9SPhilipp Zabel intermediate_size);
2220cd98e85aSSteve Longerbeam if (ret)
2221cd98e85aSSteve Longerbeam goto out_free;
2222cd98e85aSSteve Longerbeam if (ctx->double_buffering) {
2223cd98e85aSSteve Longerbeam ret = alloc_dma_buf(priv,
2224cd98e85aSSteve Longerbeam &ctx->rot_intermediate[1],
2225dd65d2a9SPhilipp Zabel intermediate_size);
2226cd98e85aSSteve Longerbeam if (ret)
2227cd98e85aSSteve Longerbeam goto out_free_dmabuf0;
2228cd98e85aSSteve Longerbeam }
2229cd98e85aSSteve Longerbeam }
2230cd98e85aSSteve Longerbeam
2231cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
2232cd98e85aSSteve Longerbeam
2233cd98e85aSSteve Longerbeam get_res = list_empty(&chan->ctx_list);
2234cd98e85aSSteve Longerbeam
2235cd98e85aSSteve Longerbeam list_add_tail(&ctx->list, &chan->ctx_list);
2236cd98e85aSSteve Longerbeam
2237cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
2238cd98e85aSSteve Longerbeam
2239cd98e85aSSteve Longerbeam if (get_res) {
2240cd98e85aSSteve Longerbeam ret = get_ipu_resources(chan);
2241cd98e85aSSteve Longerbeam if (ret)
2242cd98e85aSSteve Longerbeam goto out_free_dmabuf1;
2243cd98e85aSSteve Longerbeam }
2244cd98e85aSSteve Longerbeam
2245cd98e85aSSteve Longerbeam return ctx;
2246cd98e85aSSteve Longerbeam
2247cd98e85aSSteve Longerbeam out_free_dmabuf1:
2248cd98e85aSSteve Longerbeam free_dma_buf(priv, &ctx->rot_intermediate[1]);
2249cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
2250cd98e85aSSteve Longerbeam list_del(&ctx->list);
2251cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
2252cd98e85aSSteve Longerbeam out_free_dmabuf0:
2253cd98e85aSSteve Longerbeam free_dma_buf(priv, &ctx->rot_intermediate[0]);
2254cd98e85aSSteve Longerbeam out_free:
2255cd98e85aSSteve Longerbeam kfree(ctx);
2256cd98e85aSSteve Longerbeam return ERR_PTR(ret);
2257cd98e85aSSteve Longerbeam }
2258cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_prepare);
2259cd98e85aSSteve Longerbeam
2260cd98e85aSSteve Longerbeam /*
2261cd98e85aSSteve Longerbeam * Carry out a single image conversion run. Only the physaddr's of the input
2262cd98e85aSSteve Longerbeam * and output image buffers are needed. The conversion context must have
2263cd98e85aSSteve Longerbeam * been created previously with ipu_image_convert_prepare().
2264cd98e85aSSteve Longerbeam */
ipu_image_convert_queue(struct ipu_image_convert_run * run)2265cd98e85aSSteve Longerbeam int ipu_image_convert_queue(struct ipu_image_convert_run *run)
2266cd98e85aSSteve Longerbeam {
2267cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan;
2268cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv;
2269cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx;
2270cd98e85aSSteve Longerbeam unsigned long flags;
2271cd98e85aSSteve Longerbeam int ret = 0;
2272cd98e85aSSteve Longerbeam
2273cd98e85aSSteve Longerbeam if (!run || !run->ctx || !run->in_phys || !run->out_phys)
2274cd98e85aSSteve Longerbeam return -EINVAL;
2275cd98e85aSSteve Longerbeam
2276cd98e85aSSteve Longerbeam ctx = run->ctx;
2277cd98e85aSSteve Longerbeam chan = ctx->chan;
2278cd98e85aSSteve Longerbeam priv = chan->priv;
2279cd98e85aSSteve Longerbeam
2280cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev, "%s: task %u: ctx %p run %p\n", __func__,
2281cd98e85aSSteve Longerbeam chan->ic_task, ctx, run);
2282cd98e85aSSteve Longerbeam
2283cd98e85aSSteve Longerbeam INIT_LIST_HEAD(&run->list);
2284cd98e85aSSteve Longerbeam
2285cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
2286cd98e85aSSteve Longerbeam
2287cd98e85aSSteve Longerbeam if (ctx->aborting) {
2288cd98e85aSSteve Longerbeam ret = -EIO;
2289cd98e85aSSteve Longerbeam goto unlock;
2290cd98e85aSSteve Longerbeam }
2291cd98e85aSSteve Longerbeam
2292cd98e85aSSteve Longerbeam list_add_tail(&run->list, &chan->pending_q);
2293cd98e85aSSteve Longerbeam
2294cd98e85aSSteve Longerbeam if (!chan->current_run) {
2295cd98e85aSSteve Longerbeam ret = do_run(run);
2296cd98e85aSSteve Longerbeam if (ret)
2297cd98e85aSSteve Longerbeam chan->current_run = NULL;
2298cd98e85aSSteve Longerbeam }
2299cd98e85aSSteve Longerbeam unlock:
2300cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
2301cd98e85aSSteve Longerbeam return ret;
2302cd98e85aSSteve Longerbeam }
2303cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_queue);
2304cd98e85aSSteve Longerbeam
2305cd98e85aSSteve Longerbeam /* Abort any active or pending conversions for this context */
__ipu_image_convert_abort(struct ipu_image_convert_ctx * ctx)2306819bec35SSteve Longerbeam static void __ipu_image_convert_abort(struct ipu_image_convert_ctx *ctx)
2307cd98e85aSSteve Longerbeam {
2308cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
2309cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
2310cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run, *active_run, *tmp;
2311cd98e85aSSteve Longerbeam unsigned long flags;
2312cd98e85aSSteve Longerbeam int run_count, ret;
2313cd98e85aSSteve Longerbeam
2314cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
2315cd98e85aSSteve Longerbeam
2316cd98e85aSSteve Longerbeam /* move all remaining pending runs in this context to done_q */
2317cd98e85aSSteve Longerbeam list_for_each_entry_safe(run, tmp, &chan->pending_q, list) {
2318cd98e85aSSteve Longerbeam if (run->ctx != ctx)
2319cd98e85aSSteve Longerbeam continue;
2320cd98e85aSSteve Longerbeam run->status = -EIO;
2321cd98e85aSSteve Longerbeam list_move_tail(&run->list, &chan->done_q);
2322cd98e85aSSteve Longerbeam }
2323cd98e85aSSteve Longerbeam
2324cd98e85aSSteve Longerbeam run_count = get_run_count(ctx, &chan->done_q);
2325cd98e85aSSteve Longerbeam active_run = (chan->current_run && chan->current_run->ctx == ctx) ?
2326cd98e85aSSteve Longerbeam chan->current_run : NULL;
2327cd98e85aSSteve Longerbeam
2328aa60b261SSteve Longerbeam if (active_run)
2329aa60b261SSteve Longerbeam reinit_completion(&ctx->aborted);
2330aa60b261SSteve Longerbeam
2331819bec35SSteve Longerbeam ctx->aborting = true;
2332cd98e85aSSteve Longerbeam
2333cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
2334cd98e85aSSteve Longerbeam
2335b288adadSSteve Longerbeam if (!run_count && !active_run) {
2336cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev,
2337cd98e85aSSteve Longerbeam "%s: task %u: no abort needed for ctx %p\n",
2338cd98e85aSSteve Longerbeam __func__, chan->ic_task, ctx);
2339cd98e85aSSteve Longerbeam return;
2340cd98e85aSSteve Longerbeam }
2341cd98e85aSSteve Longerbeam
2342920340aeSSteve Longerbeam if (!active_run) {
2343920340aeSSteve Longerbeam empty_done_q(chan);
2344920340aeSSteve Longerbeam return;
2345920340aeSSteve Longerbeam }
2346920340aeSSteve Longerbeam
2347cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev,
2348920340aeSSteve Longerbeam "%s: task %u: wait for completion: %d runs\n",
2349920340aeSSteve Longerbeam __func__, chan->ic_task, run_count);
2350cd98e85aSSteve Longerbeam
2351cd98e85aSSteve Longerbeam ret = wait_for_completion_timeout(&ctx->aborted,
2352cd98e85aSSteve Longerbeam msecs_to_jiffies(10000));
2353cd98e85aSSteve Longerbeam if (ret == 0) {
2354cd98e85aSSteve Longerbeam dev_warn(priv->ipu->dev, "%s: timeout\n", __func__);
2355cd98e85aSSteve Longerbeam force_abort(ctx);
2356cd98e85aSSteve Longerbeam }
2357819bec35SSteve Longerbeam }
2358cd98e85aSSteve Longerbeam
ipu_image_convert_abort(struct ipu_image_convert_ctx * ctx)2359819bec35SSteve Longerbeam void ipu_image_convert_abort(struct ipu_image_convert_ctx *ctx)
2360819bec35SSteve Longerbeam {
2361819bec35SSteve Longerbeam __ipu_image_convert_abort(ctx);
2362cd98e85aSSteve Longerbeam ctx->aborting = false;
2363cd98e85aSSteve Longerbeam }
2364cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_abort);
2365cd98e85aSSteve Longerbeam
2366cd98e85aSSteve Longerbeam /* Unprepare image conversion context */
ipu_image_convert_unprepare(struct ipu_image_convert_ctx * ctx)2367cd98e85aSSteve Longerbeam void ipu_image_convert_unprepare(struct ipu_image_convert_ctx *ctx)
2368cd98e85aSSteve Longerbeam {
2369cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = ctx->chan;
2370cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv = chan->priv;
2371cd98e85aSSteve Longerbeam unsigned long flags;
2372cd98e85aSSteve Longerbeam bool put_res;
2373cd98e85aSSteve Longerbeam
2374cd98e85aSSteve Longerbeam /* make sure no runs are hanging around */
2375819bec35SSteve Longerbeam __ipu_image_convert_abort(ctx);
2376cd98e85aSSteve Longerbeam
2377cd98e85aSSteve Longerbeam dev_dbg(priv->ipu->dev, "%s: task %u: removing ctx %p\n", __func__,
2378cd98e85aSSteve Longerbeam chan->ic_task, ctx);
2379cd98e85aSSteve Longerbeam
2380cd98e85aSSteve Longerbeam spin_lock_irqsave(&chan->irqlock, flags);
2381cd98e85aSSteve Longerbeam
2382cd98e85aSSteve Longerbeam list_del(&ctx->list);
2383cd98e85aSSteve Longerbeam
2384cd98e85aSSteve Longerbeam put_res = list_empty(&chan->ctx_list);
2385cd98e85aSSteve Longerbeam
2386cd98e85aSSteve Longerbeam spin_unlock_irqrestore(&chan->irqlock, flags);
2387cd98e85aSSteve Longerbeam
2388cd98e85aSSteve Longerbeam if (put_res)
2389cd98e85aSSteve Longerbeam release_ipu_resources(chan);
2390cd98e85aSSteve Longerbeam
2391cd98e85aSSteve Longerbeam free_dma_buf(priv, &ctx->rot_intermediate[1]);
2392cd98e85aSSteve Longerbeam free_dma_buf(priv, &ctx->rot_intermediate[0]);
2393cd98e85aSSteve Longerbeam
2394cd98e85aSSteve Longerbeam kfree(ctx);
2395cd98e85aSSteve Longerbeam }
2396cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_unprepare);
2397cd98e85aSSteve Longerbeam
2398cd98e85aSSteve Longerbeam /*
2399cd98e85aSSteve Longerbeam * "Canned" asynchronous single image conversion. Allocates and returns
2400cd98e85aSSteve Longerbeam * a new conversion run. On successful return the caller must free the
2401cd98e85aSSteve Longerbeam * run and call ipu_image_convert_unprepare() after conversion completes.
2402cd98e85aSSteve Longerbeam */
2403cd98e85aSSteve Longerbeam struct ipu_image_convert_run *
ipu_image_convert(struct ipu_soc * ipu,enum ipu_ic_task ic_task,struct ipu_image * in,struct ipu_image * out,enum ipu_rotate_mode rot_mode,ipu_image_convert_cb_t complete,void * complete_context)2404cd98e85aSSteve Longerbeam ipu_image_convert(struct ipu_soc *ipu, enum ipu_ic_task ic_task,
2405cd98e85aSSteve Longerbeam struct ipu_image *in, struct ipu_image *out,
2406cd98e85aSSteve Longerbeam enum ipu_rotate_mode rot_mode,
2407cd98e85aSSteve Longerbeam ipu_image_convert_cb_t complete,
2408cd98e85aSSteve Longerbeam void *complete_context)
2409cd98e85aSSteve Longerbeam {
2410cd98e85aSSteve Longerbeam struct ipu_image_convert_ctx *ctx;
2411cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run;
2412cd98e85aSSteve Longerbeam int ret;
2413cd98e85aSSteve Longerbeam
2414cd98e85aSSteve Longerbeam ctx = ipu_image_convert_prepare(ipu, ic_task, in, out, rot_mode,
2415cd98e85aSSteve Longerbeam complete, complete_context);
2416cd98e85aSSteve Longerbeam if (IS_ERR(ctx))
24174ad3e92cSWei Yongjun return ERR_CAST(ctx);
2418cd98e85aSSteve Longerbeam
2419cd98e85aSSteve Longerbeam run = kzalloc(sizeof(*run), GFP_KERNEL);
2420cd98e85aSSteve Longerbeam if (!run) {
2421cd98e85aSSteve Longerbeam ipu_image_convert_unprepare(ctx);
2422cd98e85aSSteve Longerbeam return ERR_PTR(-ENOMEM);
2423cd98e85aSSteve Longerbeam }
2424cd98e85aSSteve Longerbeam
2425cd98e85aSSteve Longerbeam run->ctx = ctx;
2426cd98e85aSSteve Longerbeam run->in_phys = in->phys0;
2427cd98e85aSSteve Longerbeam run->out_phys = out->phys0;
2428cd98e85aSSteve Longerbeam
2429cd98e85aSSteve Longerbeam ret = ipu_image_convert_queue(run);
2430cd98e85aSSteve Longerbeam if (ret) {
2431cd98e85aSSteve Longerbeam ipu_image_convert_unprepare(ctx);
2432cd98e85aSSteve Longerbeam kfree(run);
2433cd98e85aSSteve Longerbeam return ERR_PTR(ret);
2434cd98e85aSSteve Longerbeam }
2435cd98e85aSSteve Longerbeam
2436cd98e85aSSteve Longerbeam return run;
2437cd98e85aSSteve Longerbeam }
2438cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert);
2439cd98e85aSSteve Longerbeam
2440cd98e85aSSteve Longerbeam /* "Canned" synchronous single image conversion */
image_convert_sync_complete(struct ipu_image_convert_run * run,void * data)2441cd98e85aSSteve Longerbeam static void image_convert_sync_complete(struct ipu_image_convert_run *run,
2442cd98e85aSSteve Longerbeam void *data)
2443cd98e85aSSteve Longerbeam {
2444cd98e85aSSteve Longerbeam struct completion *comp = data;
2445cd98e85aSSteve Longerbeam
2446cd98e85aSSteve Longerbeam complete(comp);
2447cd98e85aSSteve Longerbeam }
2448cd98e85aSSteve Longerbeam
ipu_image_convert_sync(struct ipu_soc * ipu,enum ipu_ic_task ic_task,struct ipu_image * in,struct ipu_image * out,enum ipu_rotate_mode rot_mode)2449cd98e85aSSteve Longerbeam int ipu_image_convert_sync(struct ipu_soc *ipu, enum ipu_ic_task ic_task,
2450cd98e85aSSteve Longerbeam struct ipu_image *in, struct ipu_image *out,
2451cd98e85aSSteve Longerbeam enum ipu_rotate_mode rot_mode)
2452cd98e85aSSteve Longerbeam {
2453cd98e85aSSteve Longerbeam struct ipu_image_convert_run *run;
2454cd98e85aSSteve Longerbeam struct completion comp;
2455cd98e85aSSteve Longerbeam int ret;
2456cd98e85aSSteve Longerbeam
2457cd98e85aSSteve Longerbeam init_completion(&comp);
2458cd98e85aSSteve Longerbeam
2459cd98e85aSSteve Longerbeam run = ipu_image_convert(ipu, ic_task, in, out, rot_mode,
2460cd98e85aSSteve Longerbeam image_convert_sync_complete, &comp);
2461cd98e85aSSteve Longerbeam if (IS_ERR(run))
2462cd98e85aSSteve Longerbeam return PTR_ERR(run);
2463cd98e85aSSteve Longerbeam
2464cd98e85aSSteve Longerbeam ret = wait_for_completion_timeout(&comp, msecs_to_jiffies(10000));
2465cd98e85aSSteve Longerbeam ret = (ret == 0) ? -ETIMEDOUT : 0;
2466cd98e85aSSteve Longerbeam
2467cd98e85aSSteve Longerbeam ipu_image_convert_unprepare(run->ctx);
2468cd98e85aSSteve Longerbeam kfree(run);
2469cd98e85aSSteve Longerbeam
2470cd98e85aSSteve Longerbeam return ret;
2471cd98e85aSSteve Longerbeam }
2472cd98e85aSSteve Longerbeam EXPORT_SYMBOL_GPL(ipu_image_convert_sync);
2473cd98e85aSSteve Longerbeam
ipu_image_convert_init(struct ipu_soc * ipu,struct device * dev)2474cd98e85aSSteve Longerbeam int ipu_image_convert_init(struct ipu_soc *ipu, struct device *dev)
2475cd98e85aSSteve Longerbeam {
2476cd98e85aSSteve Longerbeam struct ipu_image_convert_priv *priv;
2477cd98e85aSSteve Longerbeam int i;
2478cd98e85aSSteve Longerbeam
2479cd98e85aSSteve Longerbeam priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
2480cd98e85aSSteve Longerbeam if (!priv)
2481cd98e85aSSteve Longerbeam return -ENOMEM;
2482cd98e85aSSteve Longerbeam
2483cd98e85aSSteve Longerbeam ipu->image_convert_priv = priv;
2484cd98e85aSSteve Longerbeam priv->ipu = ipu;
2485cd98e85aSSteve Longerbeam
2486cd98e85aSSteve Longerbeam for (i = 0; i < IC_NUM_TASKS; i++) {
2487cd98e85aSSteve Longerbeam struct ipu_image_convert_chan *chan = &priv->chan[i];
2488cd98e85aSSteve Longerbeam
2489cd98e85aSSteve Longerbeam chan->ic_task = i;
2490cd98e85aSSteve Longerbeam chan->priv = priv;
2491cd98e85aSSteve Longerbeam chan->dma_ch = &image_convert_dma_chan[i];
2492dd81d821SSteve Longerbeam chan->in_eof_irq = -1;
2493dd81d821SSteve Longerbeam chan->rot_in_eof_irq = -1;
2494cd98e85aSSteve Longerbeam chan->out_eof_irq = -1;
2495cd98e85aSSteve Longerbeam chan->rot_out_eof_irq = -1;
2496cd98e85aSSteve Longerbeam
2497cd98e85aSSteve Longerbeam spin_lock_init(&chan->irqlock);
2498cd98e85aSSteve Longerbeam INIT_LIST_HEAD(&chan->ctx_list);
2499cd98e85aSSteve Longerbeam INIT_LIST_HEAD(&chan->pending_q);
2500cd98e85aSSteve Longerbeam INIT_LIST_HEAD(&chan->done_q);
2501cd98e85aSSteve Longerbeam }
2502cd98e85aSSteve Longerbeam
2503cd98e85aSSteve Longerbeam return 0;
2504cd98e85aSSteve Longerbeam }
2505cd98e85aSSteve Longerbeam
ipu_image_convert_exit(struct ipu_soc * ipu)2506cd98e85aSSteve Longerbeam void ipu_image_convert_exit(struct ipu_soc *ipu)
2507cd98e85aSSteve Longerbeam {
2508cd98e85aSSteve Longerbeam }
2509