Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
omap_voutlib.c
Go to the documentation of this file.
1 /*
2  * omap_voutlib.c
3  *
4  * Copyright (C) 2005-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  * Based on the OMAP2 camera driver
11  * Video-for-Linux (Version 2) camera capture driver for
12  * the OMAP24xx camera controller.
13  *
14  * Author: Andy Lowe ([email protected])
15  *
16  * Copyright (C) 2004 MontaVista Software, Inc.
17  * Copyright (C) 2010 Texas Instruments.
18  *
19  */
20 
21 #include <linux/module.h>
22 #include <linux/errno.h>
23 #include <linux/kernel.h>
24 #include <linux/types.h>
25 #include <linux/videodev2.h>
26 
27 #include <linux/dma-mapping.h>
28 
29 #include <plat/cpu.h>
30 
31 #include "omap_voutlib.h"
32 
33 MODULE_AUTHOR("Texas Instruments");
34 MODULE_DESCRIPTION("OMAP Video library");
35 MODULE_LICENSE("GPL");
36 
37 /* Return the default overlay cropping rectangle in crop given the image
38  * size in pix and the video display size in fbuf. The default
39  * cropping rectangle is the largest rectangle no larger than the capture size
40  * that will fit on the display. The default cropping rectangle is centered in
41  * the image. All dimensions and offsets are rounded down to even numbers.
42  */
44  struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop)
45 {
46  crop->width = (pix->width < fbuf->fmt.width) ?
47  pix->width : fbuf->fmt.width;
48  crop->height = (pix->height < fbuf->fmt.height) ?
49  pix->height : fbuf->fmt.height;
50  crop->width &= ~1;
51  crop->height &= ~1;
52  crop->left = ((pix->width - crop->width) >> 1) & ~1;
53  crop->top = ((pix->height - crop->height) >> 1) & ~1;
54 }
56 
57 /* Given a new render window in new_win, adjust the window to the
58  * nearest supported configuration. The adjusted window parameters are
59  * returned in new_win.
60  * Returns zero if successful, or -EINVAL if the requested window is
61  * impossible and cannot reasonably be adjusted.
62  */
64  struct v4l2_window *new_win)
65 {
66  struct v4l2_rect try_win;
67 
68  /* make a working copy of the new_win rectangle */
69  try_win = new_win->w;
70 
71  /* adjust the preview window so it fits on the display by clipping any
72  * offscreen areas
73  */
74  if (try_win.left < 0) {
75  try_win.width += try_win.left;
76  try_win.left = 0;
77  }
78  if (try_win.top < 0) {
79  try_win.height += try_win.top;
80  try_win.top = 0;
81  }
82  try_win.width = (try_win.width < fbuf->fmt.width) ?
83  try_win.width : fbuf->fmt.width;
84  try_win.height = (try_win.height < fbuf->fmt.height) ?
85  try_win.height : fbuf->fmt.height;
86  if (try_win.left + try_win.width > fbuf->fmt.width)
87  try_win.width = fbuf->fmt.width - try_win.left;
88  if (try_win.top + try_win.height > fbuf->fmt.height)
89  try_win.height = fbuf->fmt.height - try_win.top;
90  try_win.width &= ~1;
91  try_win.height &= ~1;
92 
93  if (try_win.width <= 0 || try_win.height <= 0)
94  return -EINVAL;
95 
96  /* We now have a valid preview window, so go with it */
97  new_win->w = try_win;
98  new_win->field = V4L2_FIELD_ANY;
99  return 0;
100 }
102 
103 /* Given a new render window in new_win, adjust the window to the
104  * nearest supported configuration. The image cropping window in crop
105  * will also be adjusted if necessary. Preference is given to keeping the
106  * the window as close to the requested configuration as possible. If
107  * successful, new_win, vout->win, and crop are updated.
108  * Returns zero if successful, or -EINVAL if the requested preview window is
109  * impossible and cannot reasonably be adjusted.
110  */
112  struct v4l2_window *win, struct v4l2_framebuffer *fbuf,
113  struct v4l2_window *new_win)
114 {
115  int err;
116 
117  err = omap_vout_try_window(fbuf, new_win);
118  if (err)
119  return err;
120 
121  /* update our preview window */
122  win->w = new_win->w;
123  win->field = new_win->field;
124  win->chromakey = new_win->chromakey;
125 
126  /* Adjust the cropping window to allow for resizing limitation */
127  if (cpu_is_omap24xx()) {
128  /* For 24xx limit is 8x to 1/2x scaling. */
129  if ((crop->height/win->w.height) >= 2)
130  crop->height = win->w.height * 2;
131 
132  if ((crop->width/win->w.width) >= 2)
133  crop->width = win->w.width * 2;
134 
135  if (crop->width > 768) {
136  /* The OMAP2420 vertical resizing line buffer is 768
137  * pixels wide. If the cropped image is wider than
138  * 768 pixels then it cannot be vertically resized.
139  */
140  if (crop->height != win->w.height)
141  crop->width = 768;
142  }
143  } else if (cpu_is_omap34xx()) {
144  /* For 34xx limit is 8x to 1/4x scaling. */
145  if ((crop->height/win->w.height) >= 4)
146  crop->height = win->w.height * 4;
147 
148  if ((crop->width/win->w.width) >= 4)
149  crop->width = win->w.width * 4;
150  }
151  return 0;
152 }
154 
155 /* Given a new cropping rectangle in new_crop, adjust the cropping rectangle to
156  * the nearest supported configuration. The image render window in win will
157  * also be adjusted if necessary. The preview window is adjusted such that the
158  * horizontal and vertical rescaling ratios stay constant. If the render
159  * window would fall outside the display boundaries, the cropping rectangle
160  * will also be adjusted to maintain the rescaling ratios. If successful, crop
161  * and win are updated.
162  * Returns zero if successful, or -EINVAL if the requested cropping rectangle is
163  * impossible and cannot reasonably be adjusted.
164  */
166  struct v4l2_rect *crop, struct v4l2_window *win,
167  struct v4l2_framebuffer *fbuf, const struct v4l2_rect *new_crop)
168 {
169  struct v4l2_rect try_crop;
170  unsigned long vresize, hresize;
171 
172  /* make a working copy of the new_crop rectangle */
173  try_crop = *new_crop;
174 
175  /* adjust the cropping rectangle so it fits in the image */
176  if (try_crop.left < 0) {
177  try_crop.width += try_crop.left;
178  try_crop.left = 0;
179  }
180  if (try_crop.top < 0) {
181  try_crop.height += try_crop.top;
182  try_crop.top = 0;
183  }
184  try_crop.width = (try_crop.width < pix->width) ?
185  try_crop.width : pix->width;
186  try_crop.height = (try_crop.height < pix->height) ?
187  try_crop.height : pix->height;
188  if (try_crop.left + try_crop.width > pix->width)
189  try_crop.width = pix->width - try_crop.left;
190  if (try_crop.top + try_crop.height > pix->height)
191  try_crop.height = pix->height - try_crop.top;
192 
193  try_crop.width &= ~1;
194  try_crop.height &= ~1;
195 
196  if (try_crop.width <= 0 || try_crop.height <= 0)
197  return -EINVAL;
198 
199  if (cpu_is_omap24xx()) {
200  if (try_crop.height != win->w.height) {
201  /* If we're resizing vertically, we can't support a
202  * crop width wider than 768 pixels.
203  */
204  if (try_crop.width > 768)
205  try_crop.width = 768;
206  }
207  }
208  /* vertical resizing */
209  vresize = (1024 * try_crop.height) / win->w.height;
210  if (cpu_is_omap24xx() && (vresize > 2048))
211  vresize = 2048;
212  else if (cpu_is_omap34xx() && (vresize > 4096))
213  vresize = 4096;
214 
215  win->w.height = ((1024 * try_crop.height) / vresize) & ~1;
216  if (win->w.height == 0)
217  win->w.height = 2;
218  if (win->w.height + win->w.top > fbuf->fmt.height) {
219  /* We made the preview window extend below the bottom of the
220  * display, so clip it to the display boundary and resize the
221  * cropping height to maintain the vertical resizing ratio.
222  */
223  win->w.height = (fbuf->fmt.height - win->w.top) & ~1;
224  if (try_crop.height == 0)
225  try_crop.height = 2;
226  }
227  /* horizontal resizing */
228  hresize = (1024 * try_crop.width) / win->w.width;
229  if (cpu_is_omap24xx() && (hresize > 2048))
230  hresize = 2048;
231  else if (cpu_is_omap34xx() && (hresize > 4096))
232  hresize = 4096;
233 
234  win->w.width = ((1024 * try_crop.width) / hresize) & ~1;
235  if (win->w.width == 0)
236  win->w.width = 2;
237  if (win->w.width + win->w.left > fbuf->fmt.width) {
238  /* We made the preview window extend past the right side of the
239  * display, so clip it to the display boundary and resize the
240  * cropping width to maintain the horizontal resizing ratio.
241  */
242  win->w.width = (fbuf->fmt.width - win->w.left) & ~1;
243  if (try_crop.width == 0)
244  try_crop.width = 2;
245  }
246  if (cpu_is_omap24xx()) {
247  if ((try_crop.height/win->w.height) >= 2)
248  try_crop.height = win->w.height * 2;
249 
250  if ((try_crop.width/win->w.width) >= 2)
251  try_crop.width = win->w.width * 2;
252 
253  if (try_crop.width > 768) {
254  /* The OMAP2420 vertical resizing line buffer is
255  * 768 pixels wide. If the cropped image is wider
256  * than 768 pixels then it cannot be vertically resized.
257  */
258  if (try_crop.height != win->w.height)
259  try_crop.width = 768;
260  }
261  } else if (cpu_is_omap34xx()) {
262  if ((try_crop.height/win->w.height) >= 4)
263  try_crop.height = win->w.height * 4;
264 
265  if ((try_crop.width/win->w.width) >= 4)
266  try_crop.width = win->w.width * 4;
267  }
268  /* update our cropping rectangle and we're done */
269  *crop = try_crop;
270  return 0;
271 }
273 
274 /* Given a new format in pix and fbuf, crop and win
275  * structures are initialized to default values. crop
276  * is initialized to the largest window size that will fit on the display. The
277  * crop window is centered in the image. win is initialized to
278  * the same size as crop and is centered on the display.
279  * All sizes and offsets are constrained to be even numbers.
280  */
282  struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop,
283  struct v4l2_window *win)
284 {
285  /* crop defines the preview source window in the image capture
286  * buffer
287  */
288  omap_vout_default_crop(pix, fbuf, crop);
289 
290  /* win defines the preview target window on the display */
291  win->w.width = crop->width;
292  win->w.height = crop->height;
293  win->w.left = ((fbuf->fmt.width - win->w.width) >> 1) & ~1;
294  win->w.top = ((fbuf->fmt.height - win->w.height) >> 1) & ~1;
295 }
297 
298 /*
299  * Allocate buffers
300  */
302 {
303  u32 order, size;
304  unsigned long virt_addr, addr;
305 
306  size = PAGE_ALIGN(buf_size);
307  order = get_order(size);
308  virt_addr = __get_free_pages(GFP_KERNEL, order);
309  addr = virt_addr;
310 
311  if (virt_addr) {
312  while (size > 0) {
313  SetPageReserved(virt_to_page(addr));
314  addr += PAGE_SIZE;
315  size -= PAGE_SIZE;
316  }
317  }
318  *phys_addr = (u32) virt_to_phys((void *) virt_addr);
319  return virt_addr;
320 }
321 
322 /*
323  * Free buffers
324  */
325 void omap_vout_free_buffer(unsigned long virtaddr, u32 buf_size)
326 {
327  u32 order, size;
328  unsigned long addr = virtaddr;
329 
330  size = PAGE_ALIGN(buf_size);
331  order = get_order(size);
332 
333  while (size > 0) {
334  ClearPageReserved(virt_to_page(addr));
335  addr += PAGE_SIZE;
336  size -= PAGE_SIZE;
337  }
338  free_pages((unsigned long) virtaddr, order);
339 }