2 On Screen Display cx23415 Framebuffer driver
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)
14 Copyright (c) 2003 Matt T. Yourst <yourst@yourst.com>
16 Derived from drivers/video/vesafb.c
17 Portions (c) 1998 Gerd Knorr <kraxel@goldbach.in-berlin.de>
20 Copyright (C) 2004 Matthias Badaire
22 Copyright (C) 2004 Chris Kennedy <c@groovy.org>
24 Copyright (C) 2006 Ian Armstrong <ian@iarmst.demon.co.uk>
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.
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.
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
41 #include <linux/module.h>
42 #include <linux/kernel.h>
44 #include <linux/ivtvfb.h>
50 #include "ivtv-driver.h"
51 #include "ivtv-udma.h"
52 #include "ivtv-mailbox.h"
55 static int ivtvfb_card_id = -1;
56 static int ivtvfb_debug = 0;
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);
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");
77 MODULE_PARM_DESC(debug,
78 "Debug level (bitmask). Default: errors only\n"
79 "\t\t\t(debug = 3 gives full debugging)");
81 /* Why upper, left, xres, yres, depth, laced ? To match terminology used
83 Why start at 1 for left & upper coordinate ? Because X doesn't allow 0 */
85 MODULE_PARM_DESC(osd_laced,
91 MODULE_PARM_DESC(osd_depth,
92 "Bits per pixel - 8, 16, 32\n"
95 MODULE_PARM_DESC(osd_upper,
96 "Vertical start position\n"
97 "\t\t\tdefault 0 (Centered)");
99 MODULE_PARM_DESC(osd_left,
100 "Horizontal start position\n"
101 "\t\t\tdefault 0 (Centered)");
103 MODULE_PARM_DESC(osd_yres,
105 "\t\t\tdefault 480 (PAL)\n"
106 "\t\t\t 400 (NTSC)");
108 MODULE_PARM_DESC(osd_xres,
110 "\t\t\tdefault 640");
112 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil, John Harvey, Ian Armstrong");
113 MODULE_LICENSE("GPL");
115 /* --------------------------------------------------------------------- */
117 #define IVTVFB_DBGFLG_WARN (1 << 0)
118 #define IVTVFB_DBGFLG_INFO (1 << 1)
120 #define IVTVFB_DEBUG(x, type, fmt, args...) \
122 if ((x) & ivtvfb_debug) \
123 printk(KERN_INFO "ivtvfb%d " type ": " fmt, itv->num , ## args); \
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)
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)
133 /* --------------------------------------------------------------------- */
135 #define IVTV_OSD_MAX_WIDTH 720
136 #define IVTV_OSD_MAX_HEIGHT 576
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
145 /* Physical base address */
146 unsigned long video_pbase;
147 /* Relative base address (relative to start of decoder memory) */
149 /* Mapped base address */
150 volatile char __iomem *video_vbase;
152 u32 video_buffer_size;
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;
161 /* Store the buffer offset */
162 int set_osd_coords_x;
163 int set_osd_coords_y;
165 /* Current dimensions (NOT VISIBLE SIZE!) */
168 int display_byte_stride;
170 /* Current bits per pixel */
174 /* Frame buffer stuff */
175 struct fb_info ivtvfb_info;
176 struct fb_var_screeninfo ivtvfb_defined;
177 struct fb_fix_screeninfo ivtvfb_fix;
180 struct ivtv_osd_coords {
181 unsigned long offset;
182 unsigned long max_offset;
189 /* --------------------------------------------------------------------- */
191 /* ivtv API calls for framebuffer related support */
193 static int ivtvfb_get_framebuffer(struct ivtv *itv, u32 *fbbase,
196 u32 data[CX2341X_MBOX_MAX_DATA];
199 rc = ivtv_vapi_result(itv, data, CX2341X_OSD_GET_FRAMEBUFFER, 0);
205 static int ivtvfb_get_osd_coords(struct ivtv *itv,
206 struct ivtv_osd_coords *osd)
208 struct osd_info *oi = itv->osd_info;
209 u32 data[CX2341X_MBOX_MAX_DATA];
211 ivtv_vapi_result(itv, data, CX2341X_OSD_GET_OSD_COORDS, 0);
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];
222 static int ivtvfb_set_osd_coords(struct ivtv *itv, const struct ivtv_osd_coords *osd)
224 struct osd_info *oi = itv->osd_info;
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;
231 return ivtv_vapi(itv, CX2341X_OSD_SET_OSD_COORDS, 5,
232 osd->offset + oi->video_rbase,
234 osd->lines, osd->x, osd->y);
237 static int ivtvfb_set_display_window(struct ivtv *itv, struct v4l2_rect *ivtv_window)
239 int osd_height_limit = itv->is_50hz ? 576 : 480;
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))
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;
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;
258 /* Set the OSD origin */
259 write_reg((ivtv_window->top << 16) | ivtv_window->left, 0x02a04);
261 /* How much to display */
262 write_reg(((ivtv_window->top+ivtv_window->height) << 16) | (ivtv_window->left+ivtv_window->width), 0x02a08);
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;
273 static int ivtvfb_prep_dec_dma_to_device(struct ivtv *itv,
274 unsigned long ivtv_dest_addr, void __user *userbuf,
281 mutex_lock(&itv->udma.lock);
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);
289 /* get_user_pages must have failed completely */
293 IVTVFB_DEBUG_INFO("ivtvfb_prep_dec_dma_to_device, %d bytes, %d pages\n",
294 size_in_bytes, itv->udma.page_count);
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
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))
309 finish_wait(&itv->dma_waitq, &wait);
311 /* Unmap Last DMA Xfer */
312 ivtv_udma_unmap(itv);
313 mutex_unlock(&itv->udma.lock);
315 IVTV_DEBUG_INFO("User stopped OSD\n");
322 static int ivtvfb_prep_frame(struct ivtv *itv, int cmd, void __user *source,
323 unsigned long dest_offset, int count)
326 struct osd_info *oi = itv->osd_info;
330 IVTVFB_DEBUG_WARN("ivtvfb_prep_frame: Nothing to do. count = 0\n");
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);
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);
347 IVTVFB_WARN("ivtvfb_prep_frame: Dest offset not 32 bit aligned (%ld)\n", dest_offset);
350 IVTVFB_WARN("ivtvfb_prep_frame: Count not a multiple of 4 (%d)\n", count);
353 if (!access_ok(VERIFY_READ, source + dest_offset, count)) {
354 IVTVFB_WARN("Invalid userspace pointer 0x%08lx\n",
355 (unsigned long)source);
357 IVTVFB_DEBUG_WARN("access_ok() failed for offset 0x%08lx source 0x%08lx count %d\n",
358 dest_offset, (unsigned long)source,
363 /* OSD Address to send DMA to */
364 dest_offset += IVTV_DECODER_OFFSET + oi->video_rbase;
367 return ivtvfb_prep_dec_dma_to_device(itv, dest_offset, source, count);
370 static ssize_t ivtvfb_write(struct fb_info *info, const char __user *buf,
371 size_t count, loff_t *ppos)
373 unsigned long p = *ppos;
376 unsigned long total_size;
377 struct ivtv *itv = (struct ivtv *) info->par;
378 unsigned long dma_offset =
379 IVTV_DECODER_OFFSET + itv->osd_info->video_rbase;
380 unsigned long dma_size;
381 u16 lead = 0, tail = 0;
383 if (info->state != FBINFO_STATE_RUNNING)
386 total_size = info->screen_size;
389 total_size = info->fix.smem_len;
394 if (count > total_size) {
399 if (count + p > total_size) {
403 count = total_size - p;
406 dst = (void __force *) (info->screen_base + p);
408 if (info->fbops->fb_sync)
409 info->fbops->fb_sync(info);
411 if (!access_ok(VERIFY_READ, buf, count)) {
412 IVTVFB_WARN("Invalid userspace pointer 0x%08lx\n",
418 /* If transfer size > threshold and both src/dst
419 addresses are aligned, use DMA */
420 if (count >= 4096 && ((u32)buf & 3) == ((u32)dst & 3)) {
421 /* Odd address = can't DMA. Align */
423 lead = 4 - ((u32)dst & 3);
424 memcpy(dst, buf, lead);
428 /* DMA resolution is 32 bits */
429 if ((count - lead) & 3)
430 tail = (count - lead) & 3;
432 dma_size = count - lead - tail;
433 err = ivtvfb_prep_dec_dma_to_device(itv,
434 p + lead + dma_offset, (void *)buf, dma_size);
437 /* Copy any leftover data */
439 memcpy(dst, buf, tail);
441 memcpy(dst, buf, count);
448 return (err) ? err : count;
451 static int ivtvfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
454 struct ivtv *itv = (struct ivtv *)info->par;
458 case FBIOGET_VBLANK: {
459 struct fb_vblank vblank;
462 vblank.flags = FB_VBLANK_HAVE_COUNT |FB_VBLANK_HAVE_VCOUNT |
463 FB_VBLANK_HAVE_VSYNC;
464 trace = read_reg(0x028c0) >> 16;
465 if (itv->is_50hz && trace > 312) trace -= 312;
466 else if (itv->is_60hz && trace > 262) trace -= 262;
467 if (trace == 1) vblank.flags |= FB_VBLANK_VSYNCING;
468 vblank.count = itv->last_vsync_field;
469 vblank.vcount = trace;
471 if (copy_to_user((void __user *)arg, &vblank, sizeof(vblank)))
476 case FBIO_WAITFORVSYNC:
477 prepare_to_wait(&itv->vsync_waitq, &wait, TASK_INTERRUPTIBLE);
478 if (!schedule_timeout(msecs_to_jiffies(50))) rc = -ETIMEDOUT;
479 finish_wait(&itv->vsync_waitq, &wait);
482 case IVTVFB_IOC_DMA_FRAME: {
483 struct ivtvfb_dma_frame args;
485 IVTVFB_DEBUG_INFO("IVTVFB_IOC_DMA_FRAME\n");
486 if (copy_from_user(&args, (void __user *)arg, sizeof(args)))
489 return ivtvfb_prep_frame(itv, cmd, args.source, args.dest_offset, args.count);
493 IVTVFB_DEBUG_INFO("Unknown ioctl %08x\n", cmd);
499 /* Framebuffer device handling */
501 static int ivtvfb_set_var(struct ivtv *itv, struct fb_var_screeninfo *var)
503 struct osd_info *oi = itv->osd_info;
504 struct ivtv_osd_coords ivtv_osd;
505 struct v4l2_rect ivtv_window;
508 IVTVFB_DEBUG_INFO("ivtvfb_set_var\n");
510 /* Select color space */
511 if (var->nonstd) /* YUV */
512 write_reg(read_reg(0x02a00) | 0x0002000, 0x02a00);
514 write_reg(read_reg(0x02a00) & ~0x0002000, 0x02a00);
516 /* Set the color mode */
517 switch (var->bits_per_pixel) {
519 osd_mode = IVTV_OSD_BPP_8;
522 osd_mode = IVTV_OSD_BPP_32;
525 switch (var->green.length) {
527 osd_mode = IVTV_OSD_BPP_16_444;
530 osd_mode = IVTV_OSD_BPP_16_555;
533 osd_mode = IVTV_OSD_BPP_16_565;
536 IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid bpp\n");
540 IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid bpp\n");
543 /* Set video mode. Although rare, the display can become scrambled even
544 if we don't change mode. Always 'bounce' to osd_mode via mode 0 */
545 if (osd_mode != -1) {
546 ivtv_vapi(itv, CX2341X_OSD_SET_PIXEL_FORMAT, 1, 0);
547 ivtv_vapi(itv, CX2341X_OSD_SET_PIXEL_FORMAT, 1, osd_mode);
550 oi->bits_per_pixel = var->bits_per_pixel;
551 oi->bytes_per_pixel = var->bits_per_pixel / 8;
553 /* Set the flicker filter */
554 switch (var->vmode & FB_VMODE_MASK) {
555 case FB_VMODE_NONINTERLACED: /* Filter on */
556 ivtv_vapi(itv, CX2341X_OSD_SET_FLICKER_STATE, 1, 1);
558 case FB_VMODE_INTERLACED: /* Filter off */
559 ivtv_vapi(itv, CX2341X_OSD_SET_FLICKER_STATE, 1, 0);
562 IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid video mode\n");
565 /* Read the current osd info */
566 ivtvfb_get_osd_coords(itv, &ivtv_osd);
568 /* Now set the OSD to the size we want */
569 ivtv_osd.pixel_stride = var->xres_virtual;
570 ivtv_osd.lines = var->yres_virtual;
573 ivtvfb_set_osd_coords(itv, &ivtv_osd);
575 /* Can't seem to find the right API combo for this.
576 Use another function which does what we need through direct register access. */
577 ivtv_window.width = var->xres;
578 ivtv_window.height = var->yres;
580 /* Minimum margin cannot be 0, as X won't allow such a mode */
581 if (!var->upper_margin) var->upper_margin++;
582 if (!var->left_margin) var->left_margin++;
583 ivtv_window.top = var->upper_margin - 1;
584 ivtv_window.left = var->left_margin - 1;
586 ivtvfb_set_display_window(itv, &ivtv_window);
588 /* Pass screen size back to yuv handler */
589 itv->yuv_info.osd_full_w = ivtv_osd.pixel_stride;
590 itv->yuv_info.osd_full_h = ivtv_osd.lines;
592 /* Force update of yuv registers */
593 itv->yuv_info.yuv_forced_update = 1;
595 IVTVFB_DEBUG_INFO("Display size: %dx%d (virtual %dx%d) @ %dbpp\n",
596 var->xres, var->yres,
597 var->xres_virtual, var->yres_virtual,
598 var->bits_per_pixel);
600 IVTVFB_DEBUG_INFO("Display position: %d, %d\n",
601 var->left_margin, var->upper_margin);
603 IVTVFB_DEBUG_INFO("Display filter: %s\n",
604 (var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED ? "on" : "off");
605 IVTVFB_DEBUG_INFO("Color space: %s\n", var->nonstd ? "YUV" : "RGB");
610 static int ivtvfb_get_fix(struct ivtv *itv, struct fb_fix_screeninfo *fix)
612 struct osd_info *oi = itv->osd_info;
614 IVTVFB_DEBUG_INFO("ivtvfb_get_fix\n");
615 memset(fix, 0, sizeof(struct fb_fix_screeninfo));
616 strlcpy(fix->id, "cx23415 TV out", sizeof(fix->id));
617 fix->smem_start = oi->video_pbase;
618 fix->smem_len = oi->video_buffer_size;
619 fix->type = FB_TYPE_PACKED_PIXELS;
620 fix->visual = (oi->bits_per_pixel == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
624 fix->line_length = oi->display_byte_stride;
625 fix->accel = FB_ACCEL_NONE;
629 /* Check the requested display mode, returning -EINVAL if we can't
632 static int _ivtvfb_check_var(struct fb_var_screeninfo *var, struct ivtv *itv)
634 struct osd_info *oi = itv->osd_info;
635 int osd_height_limit;
636 u32 pixclock, hlimit, vlimit;
638 IVTVFB_DEBUG_INFO("ivtvfb_check_var\n");
640 /* Set base references for mode calcs. */
645 osd_height_limit = 576;
651 osd_height_limit = 480;
654 if (var->bits_per_pixel == 8 || var->bits_per_pixel == 32) {
655 var->transp.offset = 24;
656 var->transp.length = 8;
657 var->red.offset = 16;
659 var->green.offset = 8;
660 var->green.length = 8;
661 var->blue.offset = 0;
662 var->blue.length = 8;
664 else if (var->bits_per_pixel == 16) {
665 /* To find out the true mode, check green length */
666 switch (var->green.length) {
670 var->green.offset = 4;
671 var->green.length = 4;
672 var->blue.offset = 0;
673 var->blue.length = 4;
674 var->transp.offset = 12;
675 var->transp.length = 1;
678 var->red.offset = 10;
680 var->green.offset = 5;
681 var->green.length = 5;
682 var->blue.offset = 0;
683 var->blue.length = 5;
684 var->transp.offset = 15;
685 var->transp.length = 1;
688 var->red.offset = 11;
690 var->green.offset = 5;
691 var->green.length = 6;
692 var->blue.offset = 0;
693 var->blue.length = 5;
694 var->transp.offset = 0;
695 var->transp.length = 0;
700 IVTVFB_DEBUG_WARN("Invalid colour mode: %d\n", var->bits_per_pixel);
704 /* Check the resolution */
705 if (var->xres > IVTV_OSD_MAX_WIDTH || var->yres > osd_height_limit) {
706 IVTVFB_DEBUG_WARN("Invalid resolution: %dx%d\n",
707 var->xres, var->yres);
711 /* Max horizontal size is 1023 @ 32bpp, 2046 & 16bpp, 4092 @ 8bpp */
712 if (var->xres_virtual > 4095 / (var->bits_per_pixel / 8) ||
713 var->xres_virtual * var->yres_virtual * (var->bits_per_pixel / 8) > oi->video_buffer_size ||
714 var->xres_virtual < var->xres ||
715 var->yres_virtual < var->yres) {
716 IVTVFB_DEBUG_WARN("Invalid virtual resolution: %dx%d\n",
717 var->xres_virtual, var->yres_virtual);
721 /* Some extra checks if in 8 bit mode */
722 if (var->bits_per_pixel == 8) {
723 /* Width must be a multiple of 4 */
725 IVTVFB_DEBUG_WARN("Invalid resolution for 8bpp: %d\n", var->xres);
728 if (var->xres_virtual & 3) {
729 IVTVFB_DEBUG_WARN("Invalid virtual resolution for 8bpp: %d)\n", var->xres_virtual);
733 else if (var->bits_per_pixel == 16) {
734 /* Width must be a multiple of 2 */
736 IVTVFB_DEBUG_WARN("Invalid resolution for 16bpp: %d\n", var->xres);
739 if (var->xres_virtual & 1) {
740 IVTVFB_DEBUG_WARN("Invalid virtual resolution for 16bpp: %d)\n", var->xres_virtual);
745 /* Now check the offsets */
746 if (var->xoffset >= var->xres_virtual || var->yoffset >= var->yres_virtual) {
747 IVTVFB_DEBUG_WARN("Invalid offset: %d (%d) %d (%d)\n",
748 var->xoffset, var->xres_virtual, var->yoffset, var->yres_virtual);
752 /* Check pixel format */
753 if (var->nonstd > 1) {
754 IVTVFB_DEBUG_WARN("Invalid nonstd % d\n", var->nonstd);
758 /* Check video mode */
759 if (((var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED) &&
760 ((var->vmode & FB_VMODE_MASK) != FB_VMODE_INTERLACED)) {
761 IVTVFB_DEBUG_WARN("Invalid video mode: %d\n", var->vmode & FB_VMODE_MASK);
765 /* Check the left & upper margins
766 If the margins are too large, just center the screen
767 (enforcing margins causes too many problems) */
769 if (var->left_margin + var->xres > IVTV_OSD_MAX_WIDTH + 1) {
770 var->left_margin = 1 + ((IVTV_OSD_MAX_WIDTH - var->xres) / 2);
772 if (var->upper_margin + var->yres > (itv->is_50hz ? 577 : 481)) {
773 var->upper_margin = 1 + (((itv->is_50hz ? 576 : 480) - var->yres) / 2);
776 /* Maintain overall 'size' for a constant refresh rate */
777 var->right_margin = hlimit - var->left_margin - var->xres;
778 var->lower_margin = vlimit - var->upper_margin - var->yres;
780 /* Fixed sync times */
784 /* Non-interlaced / interlaced mode is used to switch the OSD filter
785 on or off. Adjust the clock timings to maintain a constant
786 vertical refresh rate. */
787 if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED)
788 var->pixclock = pixclock / 2;
790 var->pixclock = pixclock;
792 IVTVFB_DEBUG_INFO("Display size: %dx%d (virtual %dx%d) @ %dbpp\n",
793 var->xres, var->yres,
794 var->xres_virtual, var->yres_virtual,
795 var->bits_per_pixel);
797 IVTVFB_DEBUG_INFO("Display position: %d, %d\n",
798 var->left_margin, var->upper_margin);
800 IVTVFB_DEBUG_INFO("Display filter: %s\n",
801 (var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED ? "on" : "off");
802 IVTVFB_DEBUG_INFO("Color space: %s\n", var->nonstd ? "YUV" : "RGB");
806 static int ivtvfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
808 struct ivtv *itv = (struct ivtv *) info->par;
809 IVTVFB_DEBUG_INFO("ivtvfb_check_var\n");
810 return _ivtvfb_check_var(var, itv);
813 static int ivtvfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
816 struct ivtv *itv = (struct ivtv *) info->par;
818 osd_pan_index = (var->xoffset + (var->yoffset * var->xres_virtual))*var->bits_per_pixel/8;
819 write_reg(osd_pan_index, 0x02A0C);
821 /* Pass this info back the yuv handler */
822 itv->yuv_info.osd_x_pan = var->xoffset;
823 itv->yuv_info.osd_y_pan = var->yoffset;
824 /* Force update of yuv registers */
825 itv->yuv_info.yuv_forced_update = 1;
829 static int ivtvfb_set_par(struct fb_info *info)
832 struct ivtv *itv = (struct ivtv *) info->par;
834 IVTVFB_DEBUG_INFO("ivtvfb_set_par\n");
836 rc = ivtvfb_set_var(itv, &info->var);
837 ivtvfb_pan_display(&info->var, info);
838 ivtvfb_get_fix(itv, &info->fix);
842 static int ivtvfb_setcolreg(unsigned regno, unsigned red, unsigned green,
843 unsigned blue, unsigned transp,
844 struct fb_info *info)
847 struct ivtv *itv = (struct ivtv *)info->par;
849 if (regno >= info->cmap.len)
852 color = ((transp & 0xFF00) << 16) |((red & 0xFF00) << 8) | (green & 0xFF00) | ((blue & 0xFF00) >> 8);
853 if (info->var.bits_per_pixel <= 8) {
854 write_reg(regno, 0x02a30);
855 write_reg(color, 0x02a34);
861 palette = info->pseudo_palette;
862 if (info->var.bits_per_pixel == 16) {
863 switch (info->var.green.length) {
865 color = ((red & 0xf000) >> 4) |
866 ((green & 0xf000) >> 8) |
867 ((blue & 0xf000) >> 12);
870 color = ((red & 0xf800) >> 1) |
871 ((green & 0xf800) >> 6) |
872 ((blue & 0xf800) >> 11);
875 color = (red & 0xf800 ) |
876 ((green & 0xfc00) >> 5) |
877 ((blue & 0xf800) >> 11);
881 palette[regno] = color;
885 /* We don't really support blanking. All this does is enable or
887 static int ivtvfb_blank(int blank_mode, struct fb_info *info)
889 struct ivtv *itv = (struct ivtv *)info->par;
891 IVTVFB_DEBUG_INFO("Set blanking mode : %d\n", blank_mode);
892 switch (blank_mode) {
893 case FB_BLANK_UNBLANK:
894 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, 1);
896 case FB_BLANK_NORMAL:
897 case FB_BLANK_HSYNC_SUSPEND:
898 case FB_BLANK_VSYNC_SUSPEND:
899 case FB_BLANK_POWERDOWN:
900 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, 0);
906 static struct fb_ops ivtvfb_ops = {
907 .owner = THIS_MODULE,
908 .fb_write = ivtvfb_write,
909 .fb_check_var = ivtvfb_check_var,
910 .fb_set_par = ivtvfb_set_par,
911 .fb_setcolreg = ivtvfb_setcolreg,
912 .fb_fillrect = cfb_fillrect,
913 .fb_copyarea = cfb_copyarea,
914 .fb_imageblit = cfb_imageblit,
916 .fb_ioctl = ivtvfb_ioctl,
917 .fb_pan_display = ivtvfb_pan_display,
918 .fb_blank = ivtvfb_blank,
924 /* Setup our initial video mode */
925 static int ivtvfb_init_vidmode(struct ivtv *itv)
927 struct osd_info *oi = itv->osd_info;
928 struct v4l2_rect start_window;
933 if (osd_depth != 8 && osd_depth != 16 && osd_depth != 32)
935 oi->bits_per_pixel = osd_depth;
936 oi->bytes_per_pixel = oi->bits_per_pixel / 8;
938 /* Horizontal size & position */
943 /* Must be a multiple of 4 for 8bpp & 2 for 16bpp */
946 else if (osd_depth == 16)
949 start_window.width = osd_xres ? osd_xres : 640;
951 /* Check horizontal start (osd_left). */
952 if (osd_left && osd_left + start_window.width > 721) {
953 IVTVFB_ERR("Invalid osd_left - assuming default\n");
957 /* Hardware coords start at 0, user coords start at 1. */
960 start_window.left = osd_left >= 0 ? osd_left : ((IVTV_OSD_MAX_WIDTH - start_window.width) / 2);
962 oi->display_byte_stride =
963 start_window.width * oi->bytes_per_pixel;
965 /* Vertical size & position */
967 max_height = itv->is_50hz ? 576 : 480;
969 if (osd_yres > max_height)
970 osd_yres = max_height;
972 start_window.height = osd_yres ? osd_yres : itv->is_50hz ? 480 : 400;
974 /* Check vertical start (osd_upper). */
975 if (osd_upper + start_window.height > max_height + 1) {
976 IVTVFB_ERR("Invalid osd_upper - assuming default\n");
980 /* Hardware coords start at 0, user coords start at 1. */
983 start_window.top = osd_upper >= 0 ? osd_upper : ((max_height - start_window.height) / 2);
985 oi->display_width = start_window.width;
986 oi->display_height = start_window.height;
988 /* Generate a valid fb_var_screeninfo */
990 oi->ivtvfb_defined.xres = oi->display_width;
991 oi->ivtvfb_defined.yres = oi->display_height;
992 oi->ivtvfb_defined.xres_virtual = oi->display_width;
993 oi->ivtvfb_defined.yres_virtual = oi->display_height;
994 oi->ivtvfb_defined.bits_per_pixel = oi->bits_per_pixel;
995 oi->ivtvfb_defined.vmode = (osd_laced ? FB_VMODE_INTERLACED : FB_VMODE_NONINTERLACED);
996 oi->ivtvfb_defined.left_margin = start_window.left + 1;
997 oi->ivtvfb_defined.upper_margin = start_window.top + 1;
998 oi->ivtvfb_defined.accel_flags = FB_ACCEL_NONE;
999 oi->ivtvfb_defined.nonstd = 0;
1001 /* We've filled in the most data, let the usual mode check
1002 routine fill in the rest. */
1003 _ivtvfb_check_var(&oi->ivtvfb_defined, itv);
1005 /* Generate valid fb_fix_screeninfo */
1007 ivtvfb_get_fix(itv, &oi->ivtvfb_fix);
1009 /* Generate valid fb_info */
1011 oi->ivtvfb_info.node = -1;
1012 oi->ivtvfb_info.flags = FBINFO_FLAG_DEFAULT;
1013 oi->ivtvfb_info.fbops = &ivtvfb_ops;
1014 oi->ivtvfb_info.par = itv;
1015 oi->ivtvfb_info.var = oi->ivtvfb_defined;
1016 oi->ivtvfb_info.fix = oi->ivtvfb_fix;
1017 oi->ivtvfb_info.screen_base = (u8 __iomem *)oi->video_vbase;
1018 oi->ivtvfb_info.fbops = &ivtvfb_ops;
1020 /* Supply some monitor specs. Bogus values will do for now */
1021 oi->ivtvfb_info.monspecs.hfmin = 8000;
1022 oi->ivtvfb_info.monspecs.hfmax = 70000;
1023 oi->ivtvfb_info.monspecs.vfmin = 10;
1024 oi->ivtvfb_info.monspecs.vfmax = 100;
1026 /* Allocate color map */
1027 if (fb_alloc_cmap(&oi->ivtvfb_info.cmap, 256, 1)) {
1028 IVTVFB_ERR("abort, unable to alloc cmap\n");
1032 /* Allocate the pseudo palette */
1033 oi->ivtvfb_info.pseudo_palette =
1034 kmalloc(sizeof(u32) * 16, GFP_KERNEL|__GFP_NOWARN);
1036 if (!oi->ivtvfb_info.pseudo_palette) {
1037 IVTVFB_ERR("abort, unable to alloc pseudo pallete\n");
1044 /* Find OSD buffer base & size. Add to mtrr. Zero osd buffer. */
1046 static int ivtvfb_init_io(struct ivtv *itv)
1048 struct osd_info *oi = itv->osd_info;
1050 mutex_lock(&itv->serialize_lock);
1051 if (ivtv_init_on_first_open(itv)) {
1052 mutex_unlock(&itv->serialize_lock);
1053 IVTVFB_ERR("Failed to initialize ivtv\n");
1056 mutex_unlock(&itv->serialize_lock);
1058 ivtvfb_get_framebuffer(itv, &oi->video_rbase, &oi->video_buffer_size);
1060 /* The osd buffer size depends on the number of video buffers allocated
1061 on the PVR350 itself. For now we'll hardcode the smallest osd buffer
1062 size to prevent any overlap. */
1063 oi->video_buffer_size = 1704960;
1065 oi->video_pbase = itv->base_addr + IVTV_DECODER_OFFSET + oi->video_rbase;
1066 oi->video_vbase = itv->dec_mem + oi->video_rbase;
1068 if (!oi->video_vbase) {
1069 IVTVFB_ERR("abort, video memory 0x%x @ 0x%lx isn't mapped!\n",
1070 oi->video_buffer_size, oi->video_pbase);
1074 IVTVFB_INFO("Framebuffer at 0x%lx, mapped to 0x%p, size %dk\n",
1075 oi->video_pbase, oi->video_vbase,
1076 oi->video_buffer_size / 1024);
1080 /* Find the largest power of two that maps the whole buffer */
1081 int size_shift = 31;
1083 while (!(oi->video_buffer_size & (1 << size_shift))) {
1087 oi->fb_start_aligned_physaddr = oi->video_pbase & ~((1 << size_shift) - 1);
1088 oi->fb_end_aligned_physaddr = oi->video_pbase + oi->video_buffer_size;
1089 oi->fb_end_aligned_physaddr += (1 << size_shift) - 1;
1090 oi->fb_end_aligned_physaddr &= ~((1 << size_shift) - 1);
1091 if (mtrr_add(oi->fb_start_aligned_physaddr,
1092 oi->fb_end_aligned_physaddr - oi->fb_start_aligned_physaddr,
1093 MTRR_TYPE_WRCOMB, 1) < 0) {
1094 IVTVFB_INFO("disabled mttr\n");
1095 oi->fb_start_aligned_physaddr = 0;
1096 oi->fb_end_aligned_physaddr = 0;
1101 /* Blank the entire osd. */
1102 memset_io(oi->video_vbase, 0, oi->video_buffer_size);
1107 /* Release any memory we've grabbed & remove mtrr entry */
1108 static void ivtvfb_release_buffers (struct ivtv *itv)
1110 struct osd_info *oi = itv->osd_info;
1113 if (oi->ivtvfb_info.cmap.len)
1114 fb_dealloc_cmap(&oi->ivtvfb_info.cmap);
1116 /* Release pseudo palette */
1117 if (oi->ivtvfb_info.pseudo_palette)
1118 kfree(oi->ivtvfb_info.pseudo_palette);
1121 if (oi->fb_end_aligned_physaddr) {
1122 mtrr_del(-1, oi->fb_start_aligned_physaddr,
1123 oi->fb_end_aligned_physaddr - oi->fb_start_aligned_physaddr);
1128 itv->osd_info = NULL;
1131 /* Initialize the specified card */
1133 static int ivtvfb_init_card(struct ivtv *itv)
1137 if (itv->osd_info) {
1138 IVTVFB_ERR("Card %d already initialised\n", ivtvfb_card_id);
1142 itv->osd_info = kzalloc(sizeof(struct osd_info),
1143 GFP_ATOMIC|__GFP_NOWARN);
1144 if (itv->osd_info == NULL) {
1145 IVTVFB_ERR("Failed to allocate memory for osd_info\n");
1149 /* Find & setup the OSD buffer */
1150 if ((rc = ivtvfb_init_io(itv)))
1153 /* Set the startup video mode information */
1154 if ((rc = ivtvfb_init_vidmode(itv))) {
1155 ivtvfb_release_buffers(itv);
1159 /* Register the framebuffer */
1160 if (register_framebuffer(&itv->osd_info->ivtvfb_info) < 0) {
1161 ivtvfb_release_buffers(itv);
1165 itv->osd_video_pbase = itv->osd_info->video_pbase;
1167 /* Set the card to the requested mode */
1168 ivtvfb_set_par(&itv->osd_info->ivtvfb_info);
1170 /* Set color 0 to black */
1171 write_reg(0, 0x02a30);
1172 write_reg(0, 0x02a34);
1174 /* Enable the osd */
1175 ivtvfb_blank(FB_BLANK_UNBLANK, &itv->osd_info->ivtvfb_info);
1178 ivtv_udma_alloc(itv);
1183 static int __init ivtvfb_init(void)
1186 int i, registered = 0;
1188 if (ivtvfb_card_id < -1 || ivtvfb_card_id >= IVTV_MAX_CARDS) {
1189 printk(KERN_ERR "ivtvfb: ivtvfb_card_id parameter is out of range (valid range: -1 - %d)\n",
1190 IVTV_MAX_CARDS - 1);
1194 /* Locate & initialise all cards supporting an OSD. */
1195 for (i = 0; i < ivtv_cards_active; i++) {
1196 if (ivtvfb_card_id != -1 && i != ivtvfb_card_id)
1198 itv = ivtv_cards[i];
1199 if (itv && (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
1200 if (ivtvfb_init_card(itv) == 0) {
1201 IVTVFB_INFO("Framebuffer registered on ivtv card id %d\n", i);
1207 printk(KERN_ERR "ivtvfb: no cards found");
1213 static void ivtvfb_cleanup(void)
1218 printk(KERN_INFO "ivtvfb: Unloading framebuffer module\n");
1220 for (i = 0; i < ivtv_cards_active; i++) {
1221 itv = ivtv_cards[i];
1222 if (itv && (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) && itv->osd_info) {
1223 if (unregister_framebuffer(&itv->osd_info->ivtvfb_info)) {
1224 IVTVFB_WARN("Framebuffer %d is in use, cannot unload\n", i);
1227 IVTVFB_DEBUG_INFO("Unregister framebuffer %d\n", i);
1228 ivtvfb_blank(FB_BLANK_POWERDOWN, &itv->osd_info->ivtvfb_info);
1229 ivtvfb_release_buffers(itv);
1230 itv->osd_video_pbase = 0;
1235 module_init(ivtvfb_init);
1236 module_exit(ivtvfb_cleanup);