?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: introduce host commands callbacks
[linux/fpc-iii.git] / drivers / media / video / ivtv / ivtvfb.c
blob3b23fc05f7c4331dc1d15b61af39a3cb1d3133da
1 /*
2 On Screen Display cx23415 Framebuffer driver
3
4 This module presents the cx23415 OSD (onscreen display) framebuffer memory
5 as a standard Linux /dev/fb style framebuffer device. The framebuffer has
6 support for 8, 16 & 32 bpp packed pixel formats with alpha channel. In 16bpp
7 mode, there is a choice of a three color depths (12, 15 or 16 bits), but no
8 local alpha. The colorspace is selectable between rgb & yuv.
9 Depending on the TV standard configured in the ivtv module at load time,
10 the initial resolution is either 640x400 (NTSC) or 640x480 (PAL) at 8bpp.
11 Video timings are locked to ensure a vertical refresh rate of 50Hz (PAL)
12 or 59.94 (NTSC)
13
14 Copyright (c) 2003 Matt T. Yourst <yourst@yourst.com>
15
16 Derived from drivers/video/vesafb.c
17 Portions (c) 1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
18
19 2.6 kernel port:
20 Copyright (C) 2004 Matthias Badaire
21
22 Copyright (C) 2004 Chris Kennedy <c@groovy.org>
23
24 Copyright (C) 2006 Ian Armstrong <ian@iarmst.demon.co.uk>
25
26 This program is free software; you can redistribute it and/or modify
27 it under the terms of the GNU General Public License as published by
28 the Free Software Foundation; either version 2 of the License, or
29 (at your option) any later version.
30
31 This program is distributed in the hope that it will be useful,
32 but WITHOUT ANY WARRANTY; without even the implied warranty of
33 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 GNU General Public License for more details.
35
36 You should have received a copy of the GNU General Public License
37 along with this program; if not, write to the Free Software
38 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
39 */
40
41 #include <linux/module.h>
42 #include <linux/kernel.h>
43 #include <linux/fb.h>
44 #include <linux/ivtvfb.h>
45
46 #ifdef CONFIG_MTRR
47 #include <asm/mtrr.h>
48 #endif
49
50 #include "ivtv-driver.h"
51 #include "ivtv-udma.h"
52 #include "ivtv-mailbox.h"
53
54 /* card parameters */
55 static int ivtvfb_card_id = -1;
56 static int ivtvfb_debug = 0;
57 static int osd_laced;
58 static int osd_depth;
59 static int osd_upper;
60 static int osd_left;
61 static int osd_yres;
62 static int osd_xres;
63
64 module_param(ivtvfb_card_id, int, 0444);
65 module_param_named(debug,ivtvfb_debug, int, 0644);
66 module_param(osd_laced, bool, 0444);
67 module_param(osd_depth, int, 0444);
68 module_param(osd_upper, int, 0444);
69 module_param(osd_left, int, 0444);
70 module_param(osd_yres, int, 0444);
71 module_param(osd_xres, int, 0444);
72
73 MODULE_PARM_DESC(ivtvfb_card_id,
74 "Only use framebuffer of the specified ivtv card (0-31)\n"
75 "\t\t\tdefault -1: initialize all available framebuffers");
76
77 MODULE_PARM_DESC(debug,
78 "Debug level (bitmask). Default: errors only\n"
79 "\t\t\t(debug = 3 gives full debugging)");
80
81 /* Why upper, left, xres, yres, depth, laced ? To match terminology used
82 by fbset.
83 Why start at 1 for left & upper coordinate ? Because X doesn't allow 0 */
84
85 MODULE_PARM_DESC(osd_laced,
86 "Interlaced mode\n"
87 "\t\t\t0=off\n"
88 "\t\t\t1=on\n"
89 "\t\t\tdefault off");
90
91 MODULE_PARM_DESC(osd_depth,
92 "Bits per pixel - 8, 16, 32\n"
93 "\t\t\tdefault 8");
94
95 MODULE_PARM_DESC(osd_upper,
96 "Vertical start position\n"
97 "\t\t\tdefault 0 (Centered)");
98
99 MODULE_PARM_DESC(osd_left,
100 "Horizontal start position\n"
101 "\t\t\tdefault 0 (Centered)");
102
103 MODULE_PARM_DESC(osd_yres,
104 "Display height\n"
105 "\t\t\tdefault 480 (PAL)\n"
106 "\t\t\t 400 (NTSC)");
107
108 MODULE_PARM_DESC(osd_xres,
109 "Display width\n"
110 "\t\t\tdefault 640");
111
112 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil, John Harvey, Ian Armstrong");
113 MODULE_LICENSE("GPL");
114
115 /* --------------------------------------------------------------------- */
116
117 #define IVTVFB_DBGFLG_WARN (1 << 0)
118 #define IVTVFB_DBGFLG_INFO (1 << 1)
119
120 #define IVTVFB_DEBUG(x, type, fmt, args...) \
121 do { \
122 if ((x) & ivtvfb_debug) \
123 printk(KERN_INFO "ivtvfb%d " type ": " fmt, itv->num , ## args); \
124 } while (0)
125 #define IVTVFB_DEBUG_WARN(fmt, args...) IVTVFB_DEBUG(IVTVFB_DBGFLG_WARN, "warning", fmt , ## args)
126 #define IVTVFB_DEBUG_INFO(fmt, args...) IVTVFB_DEBUG(IVTVFB_DBGFLG_INFO, "info", fmt , ## args)
127
128 /* Standard kernel messages */
129 #define IVTVFB_ERR(fmt, args...) printk(KERN_ERR "ivtvfb%d: " fmt, itv->num , ## args)
130 #define IVTVFB_WARN(fmt, args...) printk(KERN_WARNING "ivtvfb%d: " fmt, itv->num , ## args)
131 #define IVTVFB_INFO(fmt, args...) printk(KERN_INFO "ivtvfb%d: " fmt, itv->num , ## args)
132
133 /* --------------------------------------------------------------------- */
134
135 #define IVTV_OSD_MAX_WIDTH 720
136 #define IVTV_OSD_MAX_HEIGHT 576
137
138 #define IVTV_OSD_BPP_8 0x00
139 #define IVTV_OSD_BPP_16_444 0x03
140 #define IVTV_OSD_BPP_16_555 0x02
141 #define IVTV_OSD_BPP_16_565 0x01
142 #define IVTV_OSD_BPP_32 0x04
143
144 struct osd_info {
145 /* Physical base address */
146 unsigned long video_pbase;
147 /* Relative base address (relative to start of decoder memory) */
148 u32 video_rbase;
149 /* Mapped base address */
150 volatile char __iomem *video_vbase;
151 /* Buffer size */
152 u32 video_buffer_size;
153
154 #ifdef CONFIG_MTRR
155 /* video_base rounded down as required by hardware MTRRs */
156 unsigned long fb_start_aligned_physaddr;
157 /* video_base rounded up as required by hardware MTRRs */
158 unsigned long fb_end_aligned_physaddr;
159 #endif
160
161 /* Store the buffer offset */
162 int set_osd_coords_x;
163 int set_osd_coords_y;
164
165 /* Current dimensions (NOT VISIBLE SIZE!) */
166 int display_width;
167 int display_height;
168 int display_byte_stride;
169
170 /* Current bits per pixel */
171 int bits_per_pixel;
172 int bytes_per_pixel;
173
174 /* Frame buffer stuff */
175 struct fb_info ivtvfb_info;
176 struct fb_var_screeninfo ivtvfb_defined;
177 struct fb_fix_screeninfo ivtvfb_fix;
178 };
179
180 struct ivtv_osd_coords {
181 unsigned long offset;
182 unsigned long max_offset;
183 int pixel_stride;
184 int lines;
185 int x;
186 int y;
187 };
188
189 /* --------------------------------------------------------------------- */
190
191 /* ivtv API calls for framebuffer related support */
192
193 static int ivtvfb_get_framebuffer(struct ivtv *itv, u32 *fbbase,
194 u32 *fblength)
195 {
196 u32 data[CX2341X_MBOX_MAX_DATA];
197 int rc;
198
199 rc = ivtv_vapi_result(itv, data, CX2341X_OSD_GET_FRAMEBUFFER, 0);
200 *fbbase = data[0];
201 *fblength = data[1];
202 return rc;
203 }
204
205 static int ivtvfb_get_osd_coords(struct ivtv *itv,
206 struct ivtv_osd_coords *osd)
207 {
208 struct osd_info *oi = itv->osd_info;
209 u32 data[CX2341X_MBOX_MAX_DATA];
210
211 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_OSD_COORDS, 0);
212
213 osd->offset = data[0] - oi->video_rbase;
214 osd->max_offset = oi->display_width * oi->display_height * 4;
215 osd->pixel_stride = data[1];
216 osd->lines = data[2];
217 osd->x = data[3];
218 osd->y = data[4];
219 return 0;
220 }
221
222 static int ivtvfb_set_osd_coords(struct ivtv *itv, const struct ivtv_osd_coords *osd)
223 {
224 struct osd_info *oi = itv->osd_info;
225
226 oi->display_width = osd->pixel_stride;
227 oi->display_byte_stride = osd->pixel_stride * oi->bytes_per_pixel;
228 oi->set_osd_coords_x += osd->x;
229 oi->set_osd_coords_y = osd->y;
230
231 return ivtv_vapi(itv, CX2341X_OSD_SET_OSD_COORDS, 5,
232 osd->offset + oi->video_rbase,
233 osd->pixel_stride,
234 osd->lines, osd->x, osd->y);
235 }
236
237 static int ivtvfb_set_display_window(struct ivtv *itv, struct v4l2_rect *ivtv_window)
238 {
239 int osd_height_limit = itv->is_50hz ? 576 : 480;
240
241 /* Only fail if resolution too high, otherwise fudge the start coords. */
242 if ((ivtv_window->height > osd_height_limit) || (ivtv_window->width > IVTV_OSD_MAX_WIDTH))
243 return -EINVAL;
244
245 /* Ensure we don't exceed display limits */
246 if (ivtv_window->top + ivtv_window->height > osd_height_limit) {
247 IVTVFB_DEBUG_WARN("ivtv_ioctl_fb_set_display_window - Invalid height setting (%d, %d)\n",
248 ivtv_window->top, ivtv_window->height);
249 ivtv_window->top = osd_height_limit - ivtv_window->height;
250 }
251
252 if (ivtv_window->left + ivtv_window->width > IVTV_OSD_MAX_WIDTH) {
253 IVTVFB_DEBUG_WARN("ivtv_ioctl_fb_set_display_window - Invalid width setting (%d, %d)\n",
254 ivtv_window->left, ivtv_window->width);
255 ivtv_window->left = IVTV_OSD_MAX_WIDTH - ivtv_window->width;
256 }
257
258 /* Set the OSD origin */
259 write_reg((ivtv_window->top << 16) | ivtv_window->left, 0x02a04);
260
261 /* How much to display */
262 write_reg(((ivtv_window->top+ivtv_window->height) << 16) | (ivtv_window->left+ivtv_window->width), 0x02a08);
263
264 /* Pass this info back the yuv handler */
265 itv->yuv_info.osd_vis_w = ivtv_window->width;
266 itv->yuv_info.osd_vis_h = ivtv_window->height;
267 itv->yuv_info.osd_x_offset = ivtv_window->left;
268 itv->yuv_info.osd_y_offset = ivtv_window->top;
269
270 return 0;
271 }
272
273 static int ivtvfb_prep_dec_dma_to_device(struct ivtv *itv,
274 unsigned long ivtv_dest_addr, void __user *userbuf,
275 int size_in_bytes)
276 {
277 DEFINE_WAIT(wait);
278 int ret = 0;
279 int got_sig = 0;
280
281 mutex_lock(&itv->udma.lock);
282 /* Map User DMA */
283 if (ivtv_udma_setup(itv, ivtv_dest_addr, userbuf, size_in_bytes) <= 0) {
284 mutex_unlock(&itv->udma.lock);
285 IVTVFB_WARN("ivtvfb_prep_dec_dma_to_device, "
286 "Error with get_user_pages: %d bytes, %d pages returned\n",
287 size_in_bytes, itv->udma.page_count);
288
289 /* get_user_pages must have failed completely */
290 return -EIO;
291 }
292
293 IVTVFB_DEBUG_INFO("ivtvfb_prep_dec_dma_to_device, %d bytes, %d pages\n",
294 size_in_bytes, itv->udma.page_count);
295
296 ivtv_udma_prepare(itv);
297 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
298 /* if no UDMA is pending and no UDMA is in progress, then the DMA
299 is finished */
300 while (itv->i_flags & (IVTV_F_I_UDMA_PENDING | IVTV_F_I_UDMA)) {
301 /* don't interrupt if the DMA is in progress but break off
302 a still pending DMA. */
303 got_sig = signal_pending(current);
304 if (got_sig && test_and_clear_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags))
305 break;
306 got_sig = 0;
307 schedule();
308 }
309 finish_wait(&itv->dma_waitq, &wait);
310
311 /* Unmap Last DMA Xfer */
312 ivtv_udma_unmap(itv);
313 mutex_unlock(&itv->udma.lock);
314 if (got_sig) {
315 IVTV_DEBUG_INFO("User stopped OSD\n");
316 return -EINTR;
317 }
318
319 return ret;
320 }
321
322 static int ivtvfb_prep_frame(struct ivtv *itv, int cmd, void __user *source,
323 unsigned long dest_offset, int count)
324 {
325 DEFINE_WAIT(wait);
326 struct osd_info *oi = itv->osd_info;
327
328 /* Nothing to do */
329 if (count == 0) {
330 IVTVFB_DEBUG_WARN("ivtvfb_prep_frame: Nothing to do. count = 0\n");
331 return -EINVAL;
332 }
333
334 /* Check Total FB Size */
335 if ((dest_offset + count) > oi->video_buffer_size) {
336 IVTVFB_WARN("ivtvfb_prep_frame: Overflowing the framebuffer %ld, only %d available\n",
337 dest_offset + count, oi->video_buffer_size);
338 return -E2BIG;
339 }
340
341 /* Not fatal, but will have undesirable results */
342 if ((unsigned long)source & 3)
343 IVTVFB_WARN("ivtvfb_prep_frame: Source address not 32 bit aligned (0x%08lx)\n",
344 (unsigned long)source);
345
346 if (dest_offset & 3)
347 IVTVFB_WARN("ivtvfb_prep_frame: Dest offset not 32 bit aligned (%ld)\n", dest_offset);
348
349 if (count & 3)
350 IVTVFB_WARN("ivtvfb_prep_frame: Count not a multiple of 4 (%d)\n", count);
351
352 /* Check Source */
353 if (!access_ok(VERIFY_READ, source + dest_offset, count)) {
354 IVTVFB_WARN("Invalid userspace pointer 0x%08lx\n",
355 (unsigned long)source);
356
357 IVTVFB_DEBUG_WARN("access_ok() failed for offset 0x%08lx source 0x%08lx count %d\n",
358 dest_offset, (unsigned long)source,
359 count);
360 return -EINVAL;
361 }
362
363 /* OSD Address to send DMA to */
364 dest_offset += IVTV_DECODER_OFFSET + oi->video_rbase;
365
366 /* Fill Buffers */
367 return ivtvfb_prep_dec_dma_to_device(itv, dest_offset, source, count);
368 }
369
370 static int ivtvfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
371 {
372 DEFINE_WAIT(wait);
373 struct ivtv *itv = (struct ivtv *)info->par;
374 int rc = 0;
375
376 switch (cmd) {
377 case FBIOGET_VBLANK: {
378 struct fb_vblank vblank;
379 u32 trace;
380
381 vblank.flags = FB_VBLANK_HAVE_COUNT |FB_VBLANK_HAVE_VCOUNT |
382 FB_VBLANK_HAVE_VSYNC;
383 trace = read_reg(0x028c0) >> 16;
384 if (itv->is_50hz && trace > 312) trace -= 312;
385 else if (itv->is_60hz && trace > 262) trace -= 262;
386 if (trace == 1) vblank.flags |= FB_VBLANK_VSYNCING;
387 vblank.count = itv->last_vsync_field;
388 vblank.vcount = trace;
389 vblank.hcount = 0;
390 if (copy_to_user((void __user *)arg, &vblank, sizeof(vblank)))
391 return -EFAULT;
392 return 0;
393 }
394
395 case FBIO_WAITFORVSYNC:
396 prepare_to_wait(&itv->vsync_waitq, &wait, TASK_INTERRUPTIBLE);
397 if (!schedule_timeout(msecs_to_jiffies(50))) rc = -ETIMEDOUT;
398 finish_wait(&itv->vsync_waitq, &wait);
399 return rc;
400
401 case IVTVFB_IOC_DMA_FRAME: {
402 struct ivtvfb_dma_frame args;
403
404 IVTVFB_DEBUG_INFO("IVTVFB_IOC_DMA_FRAME\n");
405 if (copy_from_user(&args, (void __user *)arg, sizeof(args)))
406 return -EFAULT;
407
408 return ivtvfb_prep_frame(itv, cmd, args.source, args.dest_offset, args.count);
409 }
410
411 default:
412 IVTVFB_DEBUG_INFO("Unknown ioctl %08x\n", cmd);
413 return -EINVAL;
414 }
415 return 0;
416 }
417
418 /* Framebuffer device handling */
419
420 static int ivtvfb_set_var(struct ivtv *itv, struct fb_var_screeninfo *var)
421 {
422 struct osd_info *oi = itv->osd_info;
423 struct ivtv_osd_coords ivtv_osd;
424 struct v4l2_rect ivtv_window;
425 int osd_mode = -1;
426
427 IVTVFB_DEBUG_INFO("ivtvfb_set_var\n");
428
429 /* Select color space */
430 if (var->nonstd) /* YUV */
431 write_reg(read_reg(0x02a00) | 0x0002000, 0x02a00);
432 else /* RGB */
433 write_reg(read_reg(0x02a00) & ~0x0002000, 0x02a00);
434
435 /* Set the color mode */
436 switch (var->bits_per_pixel) {
437 case 8:
438 osd_mode = IVTV_OSD_BPP_8;
439 break;
440 case 32:
441 osd_mode = IVTV_OSD_BPP_32;
442 break;
443 case 16:
444 switch (var->green.length) {
445 case 4:
446 osd_mode = IVTV_OSD_BPP_16_444;
447 break;
448 case 5:
449 osd_mode = IVTV_OSD_BPP_16_555;
450 break;
451 case 6:
452 osd_mode = IVTV_OSD_BPP_16_565;
453 break;
454 default:
455 IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid bpp\n");
456 }
457 break;
458 default:
459 IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid bpp\n");
460 }
461
462 /* Set video mode. Although rare, the display can become scrambled even
463 if we don't change mode. Always 'bounce' to osd_mode via mode 0 */
464 if (osd_mode != -1) {
465 ivtv_vapi(itv, CX2341X_OSD_SET_PIXEL_FORMAT, 1, 0);
466 ivtv_vapi(itv, CX2341X_OSD_SET_PIXEL_FORMAT, 1, osd_mode);
467 }
468
469 oi->bits_per_pixel = var->bits_per_pixel;
470 oi->bytes_per_pixel = var->bits_per_pixel / 8;
471
472 /* Set the flicker filter */
473 switch (var->vmode & FB_VMODE_MASK) {
474 case FB_VMODE_NONINTERLACED: /* Filter on */
475 ivtv_vapi(itv, CX2341X_OSD_SET_FLICKER_STATE, 1, 1);
476 break;
477 case FB_VMODE_INTERLACED: /* Filter off */
478 ivtv_vapi(itv, CX2341X_OSD_SET_FLICKER_STATE, 1, 0);
479 break;
480 default:
481 IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid video mode\n");
482 }
483
484 /* Read the current osd info */
485 ivtvfb_get_osd_coords(itv, &ivtv_osd);
486
487 /* Now set the OSD to the size we want */
488 ivtv_osd.pixel_stride = var->xres_virtual;
489 ivtv_osd.lines = var->yres_virtual;
490 ivtv_osd.x = 0;
491 ivtv_osd.y = 0;
492 ivtvfb_set_osd_coords(itv, &ivtv_osd);
493
494 /* Can't seem to find the right API combo for this.
495 Use another function which does what we need through direct register access. */
496 ivtv_window.width = var->xres;
497 ivtv_window.height = var->yres;
498
499 /* Minimum margin cannot be 0, as X won't allow such a mode */
500 if (!var->upper_margin) var->upper_margin++;
501 if (!var->left_margin) var->left_margin++;
502 ivtv_window.top = var->upper_margin - 1;
503 ivtv_window.left = var->left_margin - 1;
504
505 ivtvfb_set_display_window(itv, &ivtv_window);
506
507 /* Pass screen size back to yuv handler */
508 itv->yuv_info.osd_full_w = ivtv_osd.pixel_stride;
509 itv->yuv_info.osd_full_h = ivtv_osd.lines;
510
511 /* Force update of yuv registers */
512 itv->yuv_info.yuv_forced_update = 1;
513
514 IVTVFB_DEBUG_INFO("Display size: %dx%d (virtual %dx%d) @ %dbpp\n",
515 var->xres, var->yres,
516 var->xres_virtual, var->yres_virtual,
517 var->bits_per_pixel);
518
519 IVTVFB_DEBUG_INFO("Display position: %d, %d\n",
520 var->left_margin, var->upper_margin);
521
522 IVTVFB_DEBUG_INFO("Display filter: %s\n",
523 (var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED ? "on" : "off");
524 IVTVFB_DEBUG_INFO("Color space: %s\n", var->nonstd ? "YUV" : "RGB");
525
526 return 0;
527 }
528
529 static int ivtvfb_get_fix(struct ivtv *itv, struct fb_fix_screeninfo *fix)
530 {
531 struct osd_info *oi = itv->osd_info;
532
533 IVTVFB_DEBUG_INFO("ivtvfb_get_fix\n");
534 memset(fix, 0, sizeof(struct fb_fix_screeninfo));
535 strcpy(fix->id, "cx23415 TV out");
536 fix->smem_start = oi->video_pbase;
537 fix->smem_len = oi->video_buffer_size;
538 fix->type = FB_TYPE_PACKED_PIXELS;
539 fix->visual = (oi->bits_per_pixel == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
540 fix->xpanstep = 1;
541 fix->ypanstep = 1;
542 fix->ywrapstep = 0;
543 fix->line_length = oi->display_byte_stride;
544 fix->accel = FB_ACCEL_NONE;
545 return 0;
546 }
547
548 /* Check the requested display mode, returning -EINVAL if we can't
549 handle it. */
550
551 static int _ivtvfb_check_var(struct fb_var_screeninfo *var, struct ivtv *itv)
552 {
553 struct osd_info *oi = itv->osd_info;
554 int osd_height_limit;
555 u32 pixclock, hlimit, vlimit;
556
557 IVTVFB_DEBUG_INFO("ivtvfb_check_var\n");
558
559 /* Set base references for mode calcs. */
560 if (itv->is_50hz) {
561 pixclock = 84316;
562 hlimit = 776;
563 vlimit = 591;
564 osd_height_limit = 576;
565 }
566 else {
567 pixclock = 83926;
568 hlimit = 776;
569 vlimit = 495;
570 osd_height_limit = 480;
571 }
572
573 if (var->bits_per_pixel == 8 || var->bits_per_pixel == 32) {
574 var->transp.offset = 24;
575 var->transp.length = 8;
576 var->red.offset = 16;
577 var->red.length = 8;
578 var->green.offset = 8;
579 var->green.length = 8;
580 var->blue.offset = 0;
581 var->blue.length = 8;
582 }
583 else if (var->bits_per_pixel == 16) {
584 /* To find out the true mode, check green length */
585 switch (var->green.length) {
586 case 4:
587 var->red.offset = 8;
588 var->red.length = 4;
589 var->green.offset = 4;
590 var->green.length = 4;
591 var->blue.offset = 0;
592 var->blue.length = 4;
593 var->transp.offset = 12;
594 var->transp.length = 1;
595 break;
596 case 5:
597 var->red.offset = 10;
598 var->red.length = 5;
599 var->green.offset = 5;
600 var->green.length = 5;
601 var->blue.offset = 0;
602 var->blue.length = 5;
603 var->transp.offset = 15;
604 var->transp.length = 1;
605 break;
606 default:
607 var->red.offset = 11;
608 var->red.length = 5;
609 var->green.offset = 5;
610 var->green.length = 6;
611 var->blue.offset = 0;
612 var->blue.length = 5;
613 var->transp.offset = 0;
614 var->transp.length = 0;
615 break;
616 }
617 }
618 else {
619 IVTVFB_DEBUG_WARN("Invalid colour mode: %d\n", var->bits_per_pixel);
620 return -EINVAL;
621 }
622
623 /* Check the resolution */
624 if (var->xres > IVTV_OSD_MAX_WIDTH || var->yres > osd_height_limit) {
625 IVTVFB_DEBUG_WARN("Invalid resolution: %dx%d\n",
626 var->xres, var->yres);
627 return -EINVAL;
628 }
629
630 /* Max horizontal size is 1023 @ 32bpp, 2046 & 16bpp, 4092 @ 8bpp */
631 if (var->xres_virtual > 4095 / (var->bits_per_pixel / 8) ||
632 var->xres_virtual * var->yres_virtual * (var->bits_per_pixel / 8) > oi->video_buffer_size ||
633 var->xres_virtual < var->xres ||
634 var->yres_virtual < var->yres) {
635 IVTVFB_DEBUG_WARN("Invalid virtual resolution: %dx%d\n",
636 var->xres_virtual, var->yres_virtual);
637 return -EINVAL;
638 }
639
640 /* Some extra checks if in 8 bit mode */
641 if (var->bits_per_pixel == 8) {
642 /* Width must be a multiple of 4 */
643 if (var->xres & 3) {
644 IVTVFB_DEBUG_WARN("Invalid resolution for 8bpp: %d\n", var->xres);
645 return -EINVAL;
646 }
647 if (var->xres_virtual & 3) {
648 IVTVFB_DEBUG_WARN("Invalid virtual resolution for 8bpp: %d)\n", var->xres_virtual);
649 return -EINVAL;
650 }
651 }
652 else if (var->bits_per_pixel == 16) {
653 /* Width must be a multiple of 2 */
654 if (var->xres & 1) {
655 IVTVFB_DEBUG_WARN("Invalid resolution for 16bpp: %d\n", var->xres);
656 return -EINVAL;
657 }
658 if (var->xres_virtual & 1) {
659 IVTVFB_DEBUG_WARN("Invalid virtual resolution for 16bpp: %d)\n", var->xres_virtual);
660 return -EINVAL;
661 }
662 }
663
664 /* Now check the offsets */
665 if (var->xoffset >= var->xres_virtual || var->yoffset >= var->yres_virtual) {
666 IVTVFB_DEBUG_WARN("Invalid offset: %d (%d) %d (%d)\n",
667 var->xoffset, var->xres_virtual, var->yoffset, var->yres_virtual);
668 return -EINVAL;
669 }
670
671 /* Check pixel format */
672 if (var->nonstd > 1) {
673 IVTVFB_DEBUG_WARN("Invalid nonstd % d\n", var->nonstd);
674 return -EINVAL;
675 }
676
677 /* Check video mode */
678 if (((var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED) &&
679 ((var->vmode & FB_VMODE_MASK) != FB_VMODE_INTERLACED)) {
680 IVTVFB_DEBUG_WARN("Invalid video mode: %d\n", var->vmode & FB_VMODE_MASK);
681 return -EINVAL;
682 }
683
684 /* Check the left & upper margins
685 If the margins are too large, just center the screen
686 (enforcing margins causes too many problems) */
687
688 if (var->left_margin + var->xres > IVTV_OSD_MAX_WIDTH + 1) {
689 var->left_margin = 1 + ((IVTV_OSD_MAX_WIDTH - var->xres) / 2);
690 }
691 if (var->upper_margin + var->yres > (itv->is_50hz ? 577 : 481)) {
692 var->upper_margin = 1 + (((itv->is_50hz ? 576 : 480) - var->yres) / 2);
693 }
694
695 /* Maintain overall 'size' for a constant refresh rate */
696 var->right_margin = hlimit - var->left_margin - var->xres;
697 var->lower_margin = vlimit - var->upper_margin - var->yres;
698
699 /* Fixed sync times */
700 var->hsync_len = 24;
701 var->vsync_len = 2;
702
703 /* Non-interlaced / interlaced mode is used to switch the OSD filter
704 on or off. Adjust the clock timings to maintain a constant
705 vertical refresh rate. */
706 if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED)
707 var->pixclock = pixclock / 2;
708 else
709 var->pixclock = pixclock;
710
711 IVTVFB_DEBUG_INFO("Display size: %dx%d (virtual %dx%d) @ %dbpp\n",
712 var->xres, var->yres,
713 var->xres_virtual, var->yres_virtual,
714 var->bits_per_pixel);
715
716 IVTVFB_DEBUG_INFO("Display position: %d, %d\n",
717 var->left_margin, var->upper_margin);
718
719 IVTVFB_DEBUG_INFO("Display filter: %s\n",
720 (var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED ? "on" : "off");
721 IVTVFB_DEBUG_INFO("Color space: %s\n", var->nonstd ? "YUV" : "RGB");
722 return 0;
723 }
724
725 static int ivtvfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
726 {
727 struct ivtv *itv = (struct ivtv *) info->par;
728 IVTVFB_DEBUG_INFO("ivtvfb_check_var\n");
729 return _ivtvfb_check_var(var, itv);
730 }
731
732 static int ivtvfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
733 {
734 u32 osd_pan_index;
735 struct ivtv *itv = (struct ivtv *) info->par;
736
737 osd_pan_index = (var->xoffset + (var->yoffset * var->xres_virtual))*var->bits_per_pixel/8;
738 write_reg(osd_pan_index, 0x02A0C);
739
740 /* Pass this info back the yuv handler */
741 itv->yuv_info.osd_x_pan = var->xoffset;
742 itv->yuv_info.osd_y_pan = var->yoffset;
743 /* Force update of yuv registers */
744 itv->yuv_info.yuv_forced_update = 1;
745 return 0;
746 }
747
748 static int ivtvfb_set_par(struct fb_info *info)
749 {
750 int rc = 0;
751 struct ivtv *itv = (struct ivtv *) info->par;
752
753 IVTVFB_DEBUG_INFO("ivtvfb_set_par\n");
754
755 rc = ivtvfb_set_var(itv, &info->var);
756 ivtvfb_pan_display(&info->var, info);
757 ivtvfb_get_fix(itv, &info->fix);
758 return rc;
759 }
760
761 static int ivtvfb_setcolreg(unsigned regno, unsigned red, unsigned green,
762 unsigned blue, unsigned transp,
763 struct fb_info *info)
764 {
765 u32 color, *palette;
766 struct ivtv *itv = (struct ivtv *)info->par;
767
768 if (regno >= info->cmap.len)
769 return -EINVAL;
770
771 color = ((transp & 0xFF00) << 16) |((red & 0xFF00) << 8) | (green & 0xFF00) | ((blue & 0xFF00) >> 8);
772 if (info->var.bits_per_pixel <= 8) {
773 write_reg(regno, 0x02a30);
774 write_reg(color, 0x02a34);
775 return 0;
776 }
777 if (regno >= 16)
778 return -EINVAL;
779
780 palette = info->pseudo_palette;
781 if (info->var.bits_per_pixel == 16) {
782 switch (info->var.green.length) {
783 case 4:
784 color = ((red & 0xf000) >> 4) |
785 ((green & 0xf000) >> 8) |
786 ((blue & 0xf000) >> 12);
787 break;
788 case 5:
789 color = ((red & 0xf800) >> 1) |
790 ((green & 0xf800) >> 6) |
791 ((blue & 0xf800) >> 11);
792 break;
793 case 6:
794 color = (red & 0xf800 ) |
795 ((green & 0xfc00) >> 5) |
796 ((blue & 0xf800) >> 11);
797 break;
798 }
799 }
800 palette[regno] = color;
801 return 0;
802 }
803
804 /* We don't really support blanking. All this does is enable or
805 disable the OSD. */
806 static int ivtvfb_blank(int blank_mode, struct fb_info *info)
807 {
808 struct ivtv *itv = (struct ivtv *)info->par;
809
810 IVTVFB_DEBUG_INFO("Set blanking mode : %d\n", blank_mode);
811 switch (blank_mode) {
812 case FB_BLANK_UNBLANK:
813 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, 1);
814 break;
815 case FB_BLANK_NORMAL:
816 case FB_BLANK_HSYNC_SUSPEND:
817 case FB_BLANK_VSYNC_SUSPEND:
818 case FB_BLANK_POWERDOWN:
819 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, 0);
820 break;
821 }
822 return 0;
823 }
824
825 static struct fb_ops ivtvfb_ops = {
826 .owner = THIS_MODULE,
827 .fb_check_var = ivtvfb_check_var,
828 .fb_set_par = ivtvfb_set_par,
829 .fb_setcolreg = ivtvfb_setcolreg,
830 .fb_fillrect = cfb_fillrect,
831 .fb_copyarea = cfb_copyarea,
832 .fb_imageblit = cfb_imageblit,
833 .fb_cursor = NULL,
834 .fb_ioctl = ivtvfb_ioctl,
835 .fb_pan_display = ivtvfb_pan_display,
836 .fb_blank = ivtvfb_blank,
837 };
838
839 /* Initialization */
840
841
842 /* Setup our initial video mode */
843 static int ivtvfb_init_vidmode(struct ivtv *itv)
844 {
845 struct osd_info *oi = itv->osd_info;
846 struct v4l2_rect start_window;
847 int max_height;
848
849 /* Color mode */
850
851 if (osd_depth != 8 && osd_depth != 16 && osd_depth != 32)
852 osd_depth = 8;
853 oi->bits_per_pixel = osd_depth;
854 oi->bytes_per_pixel = oi->bits_per_pixel / 8;
855
856 /* Horizontal size & position */
857
858 if (osd_xres > 720)
859 osd_xres = 720;
860
861 /* Must be a multiple of 4 for 8bpp & 2 for 16bpp */
862 if (osd_depth == 8)
863 osd_xres &= ~3;
864 else if (osd_depth == 16)
865 osd_xres &= ~1;
866
867 start_window.width = osd_xres ? osd_xres : 640;
868
869 /* Check horizontal start (osd_left). */
870 if (osd_left && osd_left + start_window.width > 721) {
871 IVTVFB_ERR("Invalid osd_left - assuming default\n");
872 osd_left = 0;
873 }
874
875 /* Hardware coords start at 0, user coords start at 1. */
876 osd_left--;
877
878 start_window.left = osd_left >= 0 ? osd_left : ((IVTV_OSD_MAX_WIDTH - start_window.width) / 2);
879
880 oi->display_byte_stride =
881 start_window.width * oi->bytes_per_pixel;
882
883 /* Vertical size & position */
884
885 max_height = itv->is_50hz ? 576 : 480;
886
887 if (osd_yres > max_height)
888 osd_yres = max_height;
889
890 start_window.height = osd_yres ? osd_yres : itv->is_50hz ? 480 : 400;
891
892 /* Check vertical start (osd_upper). */
893 if (osd_upper + start_window.height > max_height + 1) {
894 IVTVFB_ERR("Invalid osd_upper - assuming default\n");
895 osd_upper = 0;
896 }
897
898 /* Hardware coords start at 0, user coords start at 1. */
899 osd_upper--;
900
901 start_window.top = osd_upper >= 0 ? osd_upper : ((max_height - start_window.height) / 2);
902
903 oi->display_width = start_window.width;
904 oi->display_height = start_window.height;
905
906 /* Generate a valid fb_var_screeninfo */
907
908 oi->ivtvfb_defined.xres = oi->display_width;
909 oi->ivtvfb_defined.yres = oi->display_height;
910 oi->ivtvfb_defined.xres_virtual = oi->display_width;
911 oi->ivtvfb_defined.yres_virtual = oi->display_height;
912 oi->ivtvfb_defined.bits_per_pixel = oi->bits_per_pixel;
913 oi->ivtvfb_defined.vmode = (osd_laced ? FB_VMODE_INTERLACED : FB_VMODE_NONINTERLACED);
914 oi->ivtvfb_defined.left_margin = start_window.left + 1;
915 oi->ivtvfb_defined.upper_margin = start_window.top + 1;
916 oi->ivtvfb_defined.accel_flags = FB_ACCEL_NONE;
917 oi->ivtvfb_defined.nonstd = 0;
918
919 /* We've filled in the most data, let the usual mode check
920 routine fill in the rest. */
921 _ivtvfb_check_var(&oi->ivtvfb_defined, itv);
922
923 /* Generate valid fb_fix_screeninfo */
924
925 ivtvfb_get_fix(itv, &oi->ivtvfb_fix);
926
927 /* Generate valid fb_info */
928
929 oi->ivtvfb_info.node = -1;
930 oi->ivtvfb_info.flags = FBINFO_FLAG_DEFAULT;
931 oi->ivtvfb_info.fbops = &ivtvfb_ops;
932 oi->ivtvfb_info.par = itv;
933 oi->ivtvfb_info.var = oi->ivtvfb_defined;
934 oi->ivtvfb_info.fix = oi->ivtvfb_fix;
935 oi->ivtvfb_info.screen_base = (u8 __iomem *)oi->video_vbase;
936 oi->ivtvfb_info.fbops = &ivtvfb_ops;
937
938 /* Supply some monitor specs. Bogus values will do for now */
939 oi->ivtvfb_info.monspecs.hfmin = 8000;
940 oi->ivtvfb_info.monspecs.hfmax = 70000;
941 oi->ivtvfb_info.monspecs.vfmin = 10;
942 oi->ivtvfb_info.monspecs.vfmax = 100;
943
944 /* Allocate color map */
945 if (fb_alloc_cmap(&oi->ivtvfb_info.cmap, 256, 1)) {
946 IVTVFB_ERR("abort, unable to alloc cmap\n");
947 return -ENOMEM;
948 }
949
950 /* Allocate the pseudo palette */
951 oi->ivtvfb_info.pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
952
953 if (!oi->ivtvfb_info.pseudo_palette) {
954 IVTVFB_ERR("abort, unable to alloc pseudo pallete\n");
955 return -ENOMEM;
956 }
957
958 return 0;
959 }
960
961 /* Find OSD buffer base & size. Add to mtrr. Zero osd buffer. */
962
963 static int ivtvfb_init_io(struct ivtv *itv)
964 {
965 struct osd_info *oi = itv->osd_info;
966
967 mutex_lock(&itv->serialize_lock);
968 if (ivtv_init_on_first_open(itv)) {
969 mutex_unlock(&itv->serialize_lock);
970 IVTVFB_ERR("Failed to initialize ivtv\n");
971 return -ENXIO;
972 }
973 mutex_unlock(&itv->serialize_lock);
974
975 ivtvfb_get_framebuffer(itv, &oi->video_rbase, &oi->video_buffer_size);
976
977 /* The osd buffer size depends on the number of video buffers allocated
978 on the PVR350 itself. For now we'll hardcode the smallest osd buffer
979 size to prevent any overlap. */
980 oi->video_buffer_size = 1704960;
981
982 oi->video_pbase = itv->base_addr + IVTV_DECODER_OFFSET + oi->video_rbase;
983 oi->video_vbase = itv->dec_mem + oi->video_rbase;
984
985 if (!oi->video_vbase) {
986 IVTVFB_ERR("abort, video memory 0x%x @ 0x%lx isn't mapped!\n",
987 oi->video_buffer_size, oi->video_pbase);
988 return -EIO;
989 }
990
991 IVTVFB_INFO("Framebuffer at 0x%lx, mapped to 0x%p, size %dk\n",
992 oi->video_pbase, oi->video_vbase,
993 oi->video_buffer_size / 1024);
994
995 #ifdef CONFIG_MTRR
996 {
997 /* Find the largest power of two that maps the whole buffer */
998 int size_shift = 31;
999
1000 while (!(oi->video_buffer_size & (1 << size_shift))) {
1001 size_shift--;
1002 }
1003 size_shift++;
1004 oi->fb_start_aligned_physaddr = oi->video_pbase & ~((1 << size_shift) - 1);
1005 oi->fb_end_aligned_physaddr = oi->video_pbase + oi->video_buffer_size;
1006 oi->fb_end_aligned_physaddr += (1 << size_shift) - 1;
1007 oi->fb_end_aligned_physaddr &= ~((1 << size_shift) - 1);
1008 if (mtrr_add(oi->fb_start_aligned_physaddr,
1009 oi->fb_end_aligned_physaddr - oi->fb_start_aligned_physaddr,
1010 MTRR_TYPE_WRCOMB, 1) < 0) {
1011 IVTVFB_INFO("disabled mttr\n");
1012 oi->fb_start_aligned_physaddr = 0;
1013 oi->fb_end_aligned_physaddr = 0;
1014 }
1015 }
1016 #endif
1017
1018 /* Blank the entire osd. */
1019 memset_io(oi->video_vbase, 0, oi->video_buffer_size);
1020
1021 return 0;
1022 }
1023
1024 /* Release any memory we've grabbed & remove mtrr entry */
1025 static void ivtvfb_release_buffers (struct ivtv *itv)
1026 {
1027 struct osd_info *oi = itv->osd_info;
1028
1029 /* Release cmap */
1030 if (oi->ivtvfb_info.cmap.len)
1031 fb_dealloc_cmap(&oi->ivtvfb_info.cmap);
1032
1033 /* Release pseudo palette */
1034 if (oi->ivtvfb_info.pseudo_palette)
1035 kfree(oi->ivtvfb_info.pseudo_palette);
1036
1037 #ifdef CONFIG_MTRR
1038 if (oi->fb_end_aligned_physaddr) {
1039 mtrr_del(-1, oi->fb_start_aligned_physaddr,
1040 oi->fb_end_aligned_physaddr - oi->fb_start_aligned_physaddr);
1041 }
1042 #endif
1043
1044 kfree(oi);
1045 itv->osd_info = NULL;
1046 }
1047
1048 /* Initialize the specified card */
1049
1050 static int ivtvfb_init_card(struct ivtv *itv)
1051 {
1052 int rc;
1053
1054 if (itv->osd_info) {
1055 IVTVFB_ERR("Card %d already initialised\n", ivtvfb_card_id);
1056 return -EBUSY;
1057 }
1058
1059 itv->osd_info = kzalloc(sizeof(struct osd_info), GFP_ATOMIC);
1060 if (itv->osd_info == NULL) {
1061 IVTVFB_ERR("Failed to allocate memory for osd_info\n");
1062 return -ENOMEM;
1063 }
1064
1065 /* Find & setup the OSD buffer */
1066 if ((rc = ivtvfb_init_io(itv)))
1067 return rc;
1068
1069 /* Set the startup video mode information */
1070 if ((rc = ivtvfb_init_vidmode(itv))) {
1071 ivtvfb_release_buffers(itv);
1072 return rc;
1073 }
1074
1075 /* Register the framebuffer */
1076 if (register_framebuffer(&itv->osd_info->ivtvfb_info) < 0) {
1077 ivtvfb_release_buffers(itv);
1078 return -EINVAL;
1079 }
1080
1081 itv->osd_video_pbase = itv->osd_info->video_pbase;
1082
1083 /* Set the card to the requested mode */
1084 ivtvfb_set_par(&itv->osd_info->ivtvfb_info);
1085
1086 /* Set color 0 to black */
1087 write_reg(0, 0x02a30);
1088 write_reg(0, 0x02a34);
1089
1090 /* Enable the osd */
1091 ivtvfb_blank(FB_BLANK_UNBLANK, &itv->osd_info->ivtvfb_info);
1092
1093 /* Allocate DMA */
1094 ivtv_udma_alloc(itv);
1095 return 0;
1096
1097 }
1098
1099 static int __init ivtvfb_init(void)
1100 {
1101 struct ivtv *itv;
1102 int i, registered = 0;
1103
1104 if (ivtvfb_card_id < -1 || ivtvfb_card_id >= IVTV_MAX_CARDS) {
1105 printk(KERN_ERR "ivtvfb: ivtvfb_card_id parameter is out of range (valid range: -1 - %d)\n",
1106 IVTV_MAX_CARDS - 1);
1107 return -EINVAL;
1108 }
1109
1110 /* Locate & initialise all cards supporting an OSD. */
1111 for (i = 0; i < ivtv_cards_active; i++) {
1112 if (ivtvfb_card_id != -1 && i != ivtvfb_card_id)
1113 continue;
1114 itv = ivtv_cards[i];
1115 if (itv && (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
1116 if (ivtvfb_init_card(itv) == 0) {
1117 IVTVFB_INFO("Framebuffer registered on ivtv card id %d\n", i);
1118 registered++;
1119 }
1120 }
1121 }
1122 if (!registered) {
1123 printk(KERN_ERR "ivtvfb: no cards found");
1124 return -ENODEV;
1125 }
1126 return 0;
1127 }
1128
1129 static void ivtvfb_cleanup(void)
1130 {
1131 struct ivtv *itv;
1132 int i;
1133
1134 printk(KERN_INFO "ivtvfb: Unloading framebuffer module\n");
1135
1136 for (i = 0; i < ivtv_cards_active; i++) {
1137 itv = ivtv_cards[i];
1138 if (itv && (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) && itv->osd_info) {
1139 if (unregister_framebuffer(&itv->osd_info->ivtvfb_info)) {
1140 IVTVFB_WARN("Framebuffer %d is in use, cannot unload\n", i);
1141 return;
1142 }
1143 IVTVFB_DEBUG_INFO("Unregister framebuffer %d\n", i);
1144 ivtvfb_blank(FB_BLANK_POWERDOWN, &itv->osd_info->ivtvfb_info);
1145 ivtvfb_release_buffers(itv);
1146 itv->osd_video_pbase = 0;
1147 }
1148 }
1149 }
1150
1151 module_init(ivtvfb_init);
1152 module_exit(ivtvfb_cleanup);
Linux with added FPC-III support