1 /*
2  * omap_vout_vrfb.c
3  *
4  * Copyright (C) 2010 Texas Instruments.
5  *
6  * This file is licensed under the terms of the GNU General Public License
7  * version 2. This program is licensed "as is" without any warranty of any
8  * kind, whether express or implied.
9  *
10  */
11 
12 #include <linux/sched.h>
13 #include <linux/platform_device.h>
14 #include <linux/videodev2.h>
15 #include <linux/slab.h>
16 
17 #include <media/v4l2-device.h>
18 
19 #include <video/omapvrfb.h>
20 
21 #include "omap_voutdef.h"
22 #include "omap_voutlib.h"
23 #include "omap_vout_vrfb.h"
24 
25 #define OMAP_DMA_NO_DEVICE	0
26 
27 /*
28  * Function for allocating video buffers
29  */
30 static int omap_vout_allocate_vrfb_buffers(struct omap_vout_device *vout,
31 		unsigned int *count, int startindex)
32 {
33 	int i, j;
34 
35 	for (i = 0; i < *count; i++) {
36 		if (!vout->smsshado_virt_addr[i]) {
37 			vout->smsshado_virt_addr[i] =
38 				omap_vout_alloc_buffer(vout->smsshado_size,
39 						&vout->smsshado_phy_addr[i]);
40 		}
41 		if (!vout->smsshado_virt_addr[i] && startindex != -1) {
42 			if (vout->vq.memory == V4L2_MEMORY_MMAP && i >= startindex)
43 				break;
44 		}
45 		if (!vout->smsshado_virt_addr[i]) {
46 			for (j = 0; j < i; j++) {
47 				omap_vout_free_buffer(
48 						vout->smsshado_virt_addr[j],
49 						vout->smsshado_size);
50 				vout->smsshado_virt_addr[j] = 0;
51 				vout->smsshado_phy_addr[j] = 0;
52 			}
53 			*count = 0;
54 			return -ENOMEM;
55 		}
56 		memset((void *)(long)vout->smsshado_virt_addr[i], 0,
57 		       vout->smsshado_size);
58 	}
59 	return 0;
60 }
61 
62 /*
63  * Wakes up the application once the DMA transfer to VRFB space is completed.
64  */
65 static void omap_vout_vrfb_dma_tx_callback(void *data)
66 {
67 	struct vid_vrfb_dma *t = (struct vid_vrfb_dma *) data;
68 
69 	t->tx_status = 1;
70 	wake_up_interruptible(&t->wait);
71 }
72 
73 /*
74  * Free VRFB buffers
75  */
76 void omap_vout_free_vrfb_buffers(struct omap_vout_device *vout)
77 {
78 	int j;
79 
80 	for (j = 0; j < VRFB_NUM_BUFS; j++) {
81 		if (vout->smsshado_virt_addr[j]) {
82 			omap_vout_free_buffer(vout->smsshado_virt_addr[j],
83 					      vout->smsshado_size);
84 			vout->smsshado_virt_addr[j] = 0;
85 			vout->smsshado_phy_addr[j] = 0;
86 		}
87 	}
88 }
89 
90 int omap_vout_setup_vrfb_bufs(struct platform_device *pdev, int vid_num,
91 			      bool static_vrfb_allocation)
92 {
93 	int ret = 0, i, j;
94 	struct omap_vout_device *vout;
95 	struct video_device *vfd;
96 	dma_cap_mask_t mask;
97 	int image_width, image_height;
98 	int vrfb_num_bufs = VRFB_NUM_BUFS;
99 	struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
100 	struct omap2video_device *vid_dev =
101 		container_of(v4l2_dev, struct omap2video_device, v4l2_dev);
102 
103 	vout = vid_dev->vouts[vid_num];
104 	vfd = vout->vfd;
105 
106 	for (i = 0; i < VRFB_NUM_BUFS; i++) {
107 		if (omap_vrfb_request_ctx(&vout->vrfb_context[i])) {
108 			dev_info(&pdev->dev, ": VRFB allocation failed\n");
109 			for (j = 0; j < i; j++)
110 				omap_vrfb_release_ctx(&vout->vrfb_context[j]);
111 			return -ENOMEM;
112 		}
113 	}
114 
115 	/* Calculate VRFB memory size */
116 	/* allocate for worst case size */
117 	image_width = VID_MAX_WIDTH / TILE_SIZE;
118 	if (VID_MAX_WIDTH % TILE_SIZE)
119 		image_width++;
120 
121 	image_width = image_width * TILE_SIZE;
122 	image_height = VID_MAX_HEIGHT / TILE_SIZE;
123 
124 	if (VID_MAX_HEIGHT % TILE_SIZE)
125 		image_height++;
126 
127 	image_height = image_height * TILE_SIZE;
128 	vout->smsshado_size = PAGE_ALIGN(image_width * image_height * 2 * 2);
129 
130 	/*
131 	 * Request and Initialize DMA, for DMA based VRFB transfer
132 	 */
133 	dma_cap_zero(mask);
134 	dma_cap_set(DMA_INTERLEAVE, mask);
135 	vout->vrfb_dma_tx.chan = dma_request_chan_by_mask(&mask);
136 	if (IS_ERR(vout->vrfb_dma_tx.chan)) {
137 		vout->vrfb_dma_tx.req_status = DMA_CHAN_NOT_ALLOTED;
138 	} else {
139 		size_t xt_size = sizeof(struct dma_interleaved_template) +
140 				 sizeof(struct data_chunk);
141 
142 		vout->vrfb_dma_tx.xt = kzalloc(xt_size, GFP_KERNEL);
143 		if (!vout->vrfb_dma_tx.xt) {
144 			dma_release_channel(vout->vrfb_dma_tx.chan);
145 			vout->vrfb_dma_tx.req_status = DMA_CHAN_NOT_ALLOTED;
146 		}
147 	}
148 
149 	if (vout->vrfb_dma_tx.req_status == DMA_CHAN_NOT_ALLOTED)
150 		dev_info(&pdev->dev,
151 			 ": failed to allocate DMA Channel for video%d\n",
152 			 vfd->minor);
153 
154 	init_waitqueue_head(&vout->vrfb_dma_tx.wait);
155 
156 	/*
157 	 * statically allocated the VRFB buffer is done through
158 	 * command line arguments
159 	 */
160 	if (static_vrfb_allocation) {
161 		if (omap_vout_allocate_vrfb_buffers(vout, &vrfb_num_bufs, -1)) {
162 			ret =  -ENOMEM;
163 			goto release_vrfb_ctx;
164 		}
165 		vout->vrfb_static_allocation = true;
166 	}
167 	return 0;
168 
169 release_vrfb_ctx:
170 	for (j = 0; j < VRFB_NUM_BUFS; j++)
171 		omap_vrfb_release_ctx(&vout->vrfb_context[j]);
172 	return ret;
173 }
174 
175 /*
176  * Release the VRFB context once the module exits
177  */
178 void omap_vout_release_vrfb(struct omap_vout_device *vout)
179 {
180 	int i;
181 
182 	for (i = 0; i < VRFB_NUM_BUFS; i++)
183 		omap_vrfb_release_ctx(&vout->vrfb_context[i]);
184 
185 	if (vout->vrfb_dma_tx.req_status == DMA_CHAN_ALLOTED) {
186 		vout->vrfb_dma_tx.req_status = DMA_CHAN_NOT_ALLOTED;
187 		kfree(vout->vrfb_dma_tx.xt);
188 		dmaengine_terminate_sync(vout->vrfb_dma_tx.chan);
189 		dma_release_channel(vout->vrfb_dma_tx.chan);
190 	}
191 }
192 
193 /*
194  * Allocate the buffers for the VRFB space.  Data is copied from V4L2
195  * buffers to the VRFB buffers using the DMA engine.
196  */
197 int omap_vout_vrfb_buffer_setup(struct omap_vout_device *vout,
198 			  unsigned int *count, unsigned int startindex)
199 {
200 	int i;
201 	bool yuv_mode;
202 
203 	if (!is_rotation_enabled(vout))
204 		return 0;
205 
206 	/* If rotation is enabled, allocate memory for VRFB space also */
207 	*count = *count > VRFB_NUM_BUFS ? VRFB_NUM_BUFS : *count;
208 
209 	/* Allocate the VRFB buffers only if the buffers are not
210 	 * allocated during init time.
211 	 */
212 	if (!vout->vrfb_static_allocation)
213 		if (omap_vout_allocate_vrfb_buffers(vout, count, startindex))
214 			return -ENOMEM;
215 
216 	if (vout->dss_mode == OMAP_DSS_COLOR_YUV2 ||
217 			vout->dss_mode == OMAP_DSS_COLOR_UYVY)
218 		yuv_mode = true;
219 	else
220 		yuv_mode = false;
221 
222 	for (i = 0; i < *count; i++)
223 		omap_vrfb_setup(&vout->vrfb_context[i],
224 				vout->smsshado_phy_addr[i], vout->pix.width,
225 				vout->pix.height, vout->bpp, yuv_mode);
226 
227 	return 0;
228 }
229 
230 int omap_vout_prepare_vrfb(struct omap_vout_device *vout,
231 			   struct vb2_buffer *vb)
232 {
233 	struct dma_async_tx_descriptor *tx;
234 	enum dma_ctrl_flags flags = DMA_PREP_INTERRUPT | DMA_CTRL_ACK;
235 	struct dma_chan *chan = vout->vrfb_dma_tx.chan;
236 	struct dma_interleaved_template *xt = vout->vrfb_dma_tx.xt;
237 	dma_cookie_t cookie;
238 	dma_addr_t buf_phy_addr = vb2_dma_contig_plane_dma_addr(vb, 0);
239 	enum dma_status status;
240 	enum dss_rotation rotation;
241 	size_t dst_icg;
242 	u32 pixsize;
243 
244 	if (!is_rotation_enabled(vout))
245 		return 0;
246 
247 	/* If rotation is enabled, copy input buffer into VRFB
248 	 * memory space using DMA. We are copying input buffer
249 	 * into VRFB memory space of desired angle and DSS will
250 	 * read image VRFB memory for 0 degree angle
251 	 */
252 
253 	pixsize = vout->bpp * vout->vrfb_bpp;
254 	dst_icg = MAX_PIXELS_PER_LINE * pixsize - vout->pix.width * vout->bpp;
255 
256 	xt->src_start = buf_phy_addr;
257 	xt->dst_start = vout->vrfb_context[vb->index].paddr[0];
258 
259 	xt->numf = vout->pix.height;
260 	xt->frame_size = 1;
261 	xt->sgl[0].size = vout->pix.width * vout->bpp;
262 	xt->sgl[0].icg = dst_icg;
263 
264 	xt->dir = DMA_MEM_TO_MEM;
265 	xt->src_sgl = false;
266 	xt->src_inc = true;
267 	xt->dst_sgl = true;
268 	xt->dst_inc = true;
269 
270 	tx = dmaengine_prep_interleaved_dma(chan, xt, flags);
271 	if (tx == NULL) {
272 		pr_err("%s: DMA interleaved prep error\n", __func__);
273 		return -EINVAL;
274 	}
275 
276 	tx->callback = omap_vout_vrfb_dma_tx_callback;
277 	tx->callback_param = &vout->vrfb_dma_tx;
278 
279 	cookie = dmaengine_submit(tx);
280 	if (dma_submit_error(cookie)) {
281 		pr_err("%s: dmaengine_submit failed (%d)\n", __func__, cookie);
282 		return -EINVAL;
283 	}
284 
285 	vout->vrfb_dma_tx.tx_status = 0;
286 	dma_async_issue_pending(chan);
287 
288 	wait_event_interruptible_timeout(vout->vrfb_dma_tx.wait,
289 					 vout->vrfb_dma_tx.tx_status == 1,
290 					 VRFB_TX_TIMEOUT);
291 
292 	status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);
293 
294 	if (vout->vrfb_dma_tx.tx_status == 0) {
295 		pr_err("%s: Timeout while waiting for DMA\n", __func__);
296 		dmaengine_terminate_sync(chan);
297 		return -EINVAL;
298 	} else if (status != DMA_COMPLETE) {
299 		pr_err("%s: DMA completion %s status\n", __func__,
300 		       status == DMA_ERROR ? "error" : "busy");
301 		dmaengine_terminate_sync(chan);
302 		return -EINVAL;
303 	}
304 
305 	/* Store buffers physical address into an array. Addresses
306 	 * from this array will be used to configure DSS */
307 	rotation = calc_rotation(vout);
308 	vout->queued_buf_addr[vb->index] =
309 		vout->vrfb_context[vb->index].paddr[rotation];
310 	return 0;
311 }
312 
313 /*
314  * Calculate the buffer offsets from which the streaming should
315  * start. This offset calculation is mainly required because of
316  * the VRFB 32 pixels alignment with rotation.
317  */
318 void omap_vout_calculate_vrfb_offset(struct omap_vout_device *vout)
319 {
320 	enum dss_rotation rotation;
321 	bool mirroring = vout->mirror;
322 	struct v4l2_rect *crop = &vout->crop;
323 	struct v4l2_pix_format *pix = &vout->pix;
324 	int *cropped_offset = &vout->cropped_offset;
325 	int vr_ps = 1, ps = 2, temp_ps = 2;
326 	int offset = 0, ctop = 0, cleft = 0, line_length = 0;
327 
328 	rotation = calc_rotation(vout);
329 
330 	if (V4L2_PIX_FMT_YUYV == pix->pixelformat ||
331 			V4L2_PIX_FMT_UYVY == pix->pixelformat) {
332 		if (is_rotation_enabled(vout)) {
333 			/*
334 			 * ps    - Actual pixel size for YUYV/UYVY for
335 			 *         VRFB/Mirroring is 4 bytes
336 			 * vr_ps - Virtually pixel size for YUYV/UYVY is
337 			 *         2 bytes
338 			 */
339 			ps = 4;
340 			vr_ps = 2;
341 		} else {
342 			ps = 2;	/* otherwise the pixel size is 2 byte */
343 		}
344 	} else if (V4L2_PIX_FMT_RGB32 == pix->pixelformat) {
345 		ps = 4;
346 	} else if (V4L2_PIX_FMT_RGB24 == pix->pixelformat) {
347 		ps = 3;
348 	}
349 	vout->ps = ps;
350 	vout->vr_ps = vr_ps;
351 
352 	if (is_rotation_enabled(vout)) {
353 		line_length = MAX_PIXELS_PER_LINE;
354 		ctop = (pix->height - crop->height) - crop->top;
355 		cleft = (pix->width - crop->width) - crop->left;
356 	} else {
357 		line_length = pix->width;
358 	}
359 	vout->line_length = line_length;
360 	switch (rotation) {
361 	case dss_rotation_90_degree:
362 		offset = vout->vrfb_context[0].yoffset *
363 			vout->vrfb_context[0].bytespp;
364 		temp_ps = ps / vr_ps;
365 		if (!mirroring) {
366 			*cropped_offset = offset + line_length *
367 				temp_ps * cleft + crop->top * temp_ps;
368 		} else {
369 			*cropped_offset = offset + line_length * temp_ps *
370 				cleft + crop->top * temp_ps + (line_length *
371 				((crop->width / (vr_ps)) - 1) * ps);
372 		}
373 		break;
374 	case dss_rotation_180_degree:
375 		offset = ((MAX_PIXELS_PER_LINE * vout->vrfb_context[0].yoffset *
376 			vout->vrfb_context[0].bytespp) +
377 			(vout->vrfb_context[0].xoffset *
378 			vout->vrfb_context[0].bytespp));
379 		if (!mirroring) {
380 			*cropped_offset = offset + (line_length * ps * ctop) +
381 				(cleft / vr_ps) * ps;
382 
383 		} else {
384 			*cropped_offset = offset + (line_length * ps * ctop) +
385 				(cleft / vr_ps) * ps + (line_length *
386 				(crop->height - 1) * ps);
387 		}
388 		break;
389 	case dss_rotation_270_degree:
390 		offset = MAX_PIXELS_PER_LINE * vout->vrfb_context[0].xoffset *
391 			vout->vrfb_context[0].bytespp;
392 		temp_ps = ps / vr_ps;
393 		if (!mirroring) {
394 			*cropped_offset = offset + line_length *
395 			    temp_ps * crop->left + ctop * ps;
396 		} else {
397 			*cropped_offset = offset + line_length *
398 				temp_ps * crop->left + ctop * ps +
399 				(line_length * ((crop->width / vr_ps) - 1) *
400 				 ps);
401 		}
402 		break;
403 	case dss_rotation_0_degree:
404 		if (!mirroring) {
405 			*cropped_offset = (line_length * ps) *
406 				crop->top + (crop->left / vr_ps) * ps;
407 		} else {
408 			*cropped_offset = (line_length * ps) *
409 				crop->top + (crop->left / vr_ps) * ps +
410 				(line_length * (crop->height - 1) * ps);
411 		}
412 		break;
413 	default:
414 		*cropped_offset = (line_length * ps * crop->top) /
415 			vr_ps + (crop->left * ps) / vr_ps +
416 			((crop->width / vr_ps) - 1) * ps;
417 		break;
418 	}
419 }
420