drivers/media/pci/ivtv/ivtvfb.c

   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 "ivtv-driver.h"
  42 #include "ivtv-cards.h"
  43 #include "ivtv-i2c.h"
  44 #include "ivtv-udma.h"
  45 #include "ivtv-mailbox.h"
  46 #include "ivtv-firmware.h"
  47
  48 #include <linux/fb.h>
  49 #include <linux/ivtvfb.h>
  50
  51 #ifdef CONFIG_X86_64
  52 #include <asm/pat.h>
  53 #endif
  54
  55 /* card parameters */
  56 static int ivtvfb_card_id = -1;
  57 static int ivtvfb_debug = 0;
  58 static bool osd_laced;
  59 static int osd_depth;
  60 static int osd_upper;
  61 static int osd_left;
  62 static int osd_yres;
  63 static int osd_xres;
  64
  65 module_param(ivtvfb_card_id, int, 0444);
  66 module_param_named(debug,ivtvfb_debug, int, 0644);
  67 module_param(osd_laced, bool, 0444);
  68 module_param(osd_depth, int, 0444);
  69 module_param(osd_upper, int, 0444);
  70 module_param(osd_left, int, 0444);
  71 module_param(osd_yres, int, 0444);
  72 module_param(osd_xres, int, 0444);
  73
  74 MODULE_PARM_DESC(ivtvfb_card_id,
  75                  "Only use framebuffer of the specified ivtv card (0-31)\n"
  76                  "\t\t\tdefault -1: initialize all available framebuffers");
  77
  78 MODULE_PARM_DESC(debug,
  79                  "Debug level (bitmask). Default: errors only\n"
  80                  "\t\t\t(debug = 3 gives full debugging)");
  81
  82 /* Why upper, left, xres, yres, depth, laced ? To match terminology used
  83    by fbset.
  84    Why start at 1 for left & upper coordinate ? Because X doesn't allow 0 */
  85
  86 MODULE_PARM_DESC(osd_laced,
  87                  "Interlaced mode\n"
  88                  "\t\t\t0=off\n"
  89                  "\t\t\t1=on\n"
  90                  "\t\t\tdefault off");
  91
  92 MODULE_PARM_DESC(osd_depth,
  93                  "Bits per pixel - 8, 16, 32\n"
  94                  "\t\t\tdefault 8");
  95
  96 MODULE_PARM_DESC(osd_upper,
  97                  "Vertical start position\n"
  98                  "\t\t\tdefault 0 (Centered)");
  99
 100 MODULE_PARM_DESC(osd_left,
 101                  "Horizontal start position\n"
 102                  "\t\t\tdefault 0 (Centered)");
 103
 104 MODULE_PARM_DESC(osd_yres,
 105                  "Display height\n"
 106                  "\t\t\tdefault 480 (PAL)\n"
 107                  "\t\t\t        400 (NTSC)");
 108
 109 MODULE_PARM_DESC(osd_xres,
 110                  "Display width\n"
 111                  "\t\t\tdefault 640");
 112
 113 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil, John Harvey, Ian Armstrong");
 114 MODULE_LICENSE("GPL");
 115
 116 /* --------------------------------------------------------------------- */
 117
 118 #define IVTVFB_DBGFLG_WARN  (1 << 0)
 119 #define IVTVFB_DBGFLG_INFO  (1 << 1)
 120
 121 #define IVTVFB_DEBUG(x, type, fmt, args...) \
 122         do { \
 123                 if ((x) & ivtvfb_debug) \
 124                         printk(KERN_INFO "ivtvfb%d " type ": " fmt, itv->instance , ## args); \
 125         } while (0)
 126 #define IVTVFB_DEBUG_WARN(fmt, args...)  IVTVFB_DEBUG(IVTVFB_DBGFLG_WARN, "warning", fmt , ## args)
 127 #define IVTVFB_DEBUG_INFO(fmt, args...)  IVTVFB_DEBUG(IVTVFB_DBGFLG_INFO, "info", fmt , ## args)
 128
 129 /* Standard kernel messages */
 130 #define IVTVFB_ERR(fmt, args...)   printk(KERN_ERR  "ivtvfb%d: " fmt, itv->instance , ## args)
 131 #define IVTVFB_WARN(fmt, args...)  printk(KERN_WARNING  "ivtvfb%d: " fmt, itv->instance , ## args)
 132 #define IVTVFB_INFO(fmt, args...)  printk(KERN_INFO "ivtvfb%d: " fmt, itv->instance , ## args)
 133
 134 /* --------------------------------------------------------------------- */
 135
 136 #define IVTV_OSD_MAX_WIDTH  720
 137 #define IVTV_OSD_MAX_HEIGHT 576
 138
 139 #define IVTV_OSD_BPP_8      0x00
 140 #define IVTV_OSD_BPP_16_444 0x03
 141 #define IVTV_OSD_BPP_16_555 0x02
 142 #define IVTV_OSD_BPP_16_565 0x01
 143 #define IVTV_OSD_BPP_32     0x04
 144
 145 struct osd_info {
 146         /* Physical base address */
 147         unsigned long video_pbase;
 148         /* Relative base address (relative to start of decoder memory) */
 149         u32 video_rbase;
 150         /* Mapped base address */
 151         volatile char __iomem *video_vbase;
 152         /* Buffer size */
 153         u32 video_buffer_size;
 154
 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         int wc_cookie;
 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         /* Used for a warm start */
 180         struct fb_var_screeninfo fbvar_cur;
 181         int blank_cur;
 182         u32 palette_cur[256];
 183         u32 pan_cur;
 184 };
 185
 186 struct ivtv_osd_coords {
 187         unsigned long offset;
 188         unsigned long max_offset;
 189         int pixel_stride;
 190         int lines;
 191         int x;
 192         int y;
 193 };
 194
 195 /* --------------------------------------------------------------------- */
 196
 197 /* ivtv API calls for framebuffer related support */
 198
 199 static int ivtvfb_get_framebuffer(struct ivtv *itv, u32 *fbbase,
 200                                        u32 *fblength)
 201 {
 202         u32 data[CX2341X_MBOX_MAX_DATA];
 203         int rc;
 204
 205         ivtv_firmware_check(itv, "ivtvfb_get_framebuffer");
 206         rc = ivtv_vapi_result(itv, data, CX2341X_OSD_GET_FRAMEBUFFER, 0);
 207         *fbbase = data[0];
 208         *fblength = data[1];
 209         return rc;
 210 }
 211
 212 static int ivtvfb_get_osd_coords(struct ivtv *itv,
 213                                       struct ivtv_osd_coords *osd)
 214 {
 215         struct osd_info *oi = itv->osd_info;
 216         u32 data[CX2341X_MBOX_MAX_DATA];
 217
 218         ivtv_vapi_result(itv, data, CX2341X_OSD_GET_OSD_COORDS, 0);
 219
 220         osd->offset = data[0] - oi->video_rbase;
 221         osd->max_offset = oi->display_width * oi->display_height * 4;
 222         osd->pixel_stride = data[1];
 223         osd->lines = data[2];
 224         osd->x = data[3];
 225         osd->y = data[4];
 226         return 0;
 227 }
 228
 229 static int ivtvfb_set_osd_coords(struct ivtv *itv, const struct ivtv_osd_coords *osd)
 230 {
 231         struct osd_info *oi = itv->osd_info;
 232
 233         oi->display_width = osd->pixel_stride;
 234         oi->display_byte_stride = osd->pixel_stride * oi->bytes_per_pixel;
 235         oi->set_osd_coords_x += osd->x;
 236         oi->set_osd_coords_y = osd->y;
 237
 238         return ivtv_vapi(itv, CX2341X_OSD_SET_OSD_COORDS, 5,
 239                         osd->offset + oi->video_rbase,
 240                         osd->pixel_stride,
 241                         osd->lines, osd->x, osd->y);
 242 }
 243
 244 static int ivtvfb_set_display_window(struct ivtv *itv, struct v4l2_rect *ivtv_window)
 245 {
 246         int osd_height_limit = itv->is_out_50hz ? 576 : 480;
 247
 248         /* Only fail if resolution too high, otherwise fudge the start coords. */
 249         if ((ivtv_window->height > osd_height_limit) || (ivtv_window->width > IVTV_OSD_MAX_WIDTH))
 250                 return -EINVAL;
 251
 252         /* Ensure we don't exceed display limits */
 253         if (ivtv_window->top + ivtv_window->height > osd_height_limit) {
 254                 IVTVFB_DEBUG_WARN("ivtv_ioctl_fb_set_display_window - Invalid height setting (%d, %d)\n",
 255                         ivtv_window->top, ivtv_window->height);
 256                 ivtv_window->top = osd_height_limit - ivtv_window->height;
 257         }
 258
 259         if (ivtv_window->left + ivtv_window->width > IVTV_OSD_MAX_WIDTH) {
 260                 IVTVFB_DEBUG_WARN("ivtv_ioctl_fb_set_display_window - Invalid width setting (%d, %d)\n",
 261                         ivtv_window->left, ivtv_window->width);
 262                 ivtv_window->left = IVTV_OSD_MAX_WIDTH - ivtv_window->width;
 263         }
 264
 265         /* Set the OSD origin */
 266         write_reg((ivtv_window->top << 16) | ivtv_window->left, 0x02a04);
 267
 268         /* How much to display */
 269         write_reg(((ivtv_window->top+ivtv_window->height) << 16) | (ivtv_window->left+ivtv_window->width), 0x02a08);
 270
 271         /* Pass this info back the yuv handler */
 272         itv->yuv_info.osd_vis_w = ivtv_window->width;
 273         itv->yuv_info.osd_vis_h = ivtv_window->height;
 274         itv->yuv_info.osd_x_offset = ivtv_window->left;
 275         itv->yuv_info.osd_y_offset = ivtv_window->top;
 276
 277         return 0;
 278 }
 279
 280 static int ivtvfb_prep_dec_dma_to_device(struct ivtv *itv,
 281                                   unsigned long ivtv_dest_addr, void __user *userbuf,
 282                                   int size_in_bytes)
 283 {
 284         DEFINE_WAIT(wait);
 285         int got_sig = 0;
 286
 287         mutex_lock(&itv->udma.lock);
 288         /* Map User DMA */
 289         if (ivtv_udma_setup(itv, ivtv_dest_addr, userbuf, size_in_bytes) <= 0) {
 290                 mutex_unlock(&itv->udma.lock);
 291                 IVTVFB_WARN("ivtvfb_prep_dec_dma_to_device, Error with get_user_pages: %d bytes, %d pages returned\n",
 292                                size_in_bytes, itv->udma.page_count);
 293
 294                 /* get_user_pages must have failed completely */
 295                 return -EIO;
 296         }
 297
 298         IVTVFB_DEBUG_INFO("ivtvfb_prep_dec_dma_to_device, %d bytes, %d pages\n",
 299                        size_in_bytes, itv->udma.page_count);
 300
 301         ivtv_udma_prepare(itv);
 302         prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
 303         /* if no UDMA is pending and no UDMA is in progress, then the DMA
 304            is finished */
 305         while (test_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags) ||
 306                test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
 307                 /* don't interrupt if the DMA is in progress but break off
 308                    a still pending DMA. */
 309                 got_sig = signal_pending(current);
 310                 if (got_sig && test_and_clear_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags))
 311                         break;
 312                 got_sig = 0;
 313                 schedule();
 314         }
 315         finish_wait(&itv->dma_waitq, &wait);
 316
 317         /* Unmap Last DMA Xfer */
 318         ivtv_udma_unmap(itv);
 319         mutex_unlock(&itv->udma.lock);
 320         if (got_sig) {
 321                 IVTV_DEBUG_INFO("User stopped OSD\n");
 322                 return -EINTR;
 323         }
 324
 325         return 0;
 326 }
 327
 328 static int ivtvfb_prep_frame(struct ivtv *itv, int cmd, void __user *source,
 329                               unsigned long dest_offset, int count)
 330 {
 331         DEFINE_WAIT(wait);
 332         struct osd_info *oi = itv->osd_info;
 333
 334         /* Nothing to do */
 335         if (count == 0) {
 336                 IVTVFB_DEBUG_WARN("ivtvfb_prep_frame: Nothing to do. count = 0\n");
 337                 return -EINVAL;
 338         }
 339
 340         /* Check Total FB Size */
 341         if ((dest_offset + count) > oi->video_buffer_size) {
 342                 IVTVFB_WARN("ivtvfb_prep_frame: Overflowing the framebuffer %ld, only %d available\n",
 343                         dest_offset + count, oi->video_buffer_size);
 344                 return -E2BIG;
 345         }
 346
 347         /* Not fatal, but will have undesirable results */
 348         if ((unsigned long)source & 3)
 349                 IVTVFB_WARN("ivtvfb_prep_frame: Source address not 32 bit aligned (%p)\n",
 350                             source);
 351
 352         if (dest_offset & 3)
 353                 IVTVFB_WARN("ivtvfb_prep_frame: Dest offset not 32 bit aligned (%ld)\n", dest_offset);
 354
 355         if (count & 3)
 356                 IVTVFB_WARN("ivtvfb_prep_frame: Count not a multiple of 4 (%d)\n", count);
 357
 358         /* Check Source */
 359         if (!access_ok(VERIFY_READ, source + dest_offset, count)) {
 360                 IVTVFB_WARN("Invalid userspace pointer %p\n", source);
 361
 362                 IVTVFB_DEBUG_WARN("access_ok() failed for offset 0x%08lx source %p count %d\n",
 363                                   dest_offset, source, count);
 364                 return -EINVAL;
 365         }
 366
 367         /* OSD Address to send DMA to */
 368         dest_offset += IVTV_DECODER_OFFSET + oi->video_rbase;
 369
 370         /* Fill Buffers */
 371         return ivtvfb_prep_dec_dma_to_device(itv, dest_offset, source, count);
 372 }
 373
 374 static ssize_t ivtvfb_write(struct fb_info *info, const char __user *buf,
 375                                                 size_t count, loff_t *ppos)
 376 {
 377         unsigned long p = *ppos;
 378         void *dst;
 379         int err = 0;
 380         int dma_err;
 381         unsigned long total_size;
 382         struct ivtv *itv = (struct ivtv *) info->par;
 383         unsigned long dma_offset =
 384                         IVTV_DECODER_OFFSET + itv->osd_info->video_rbase;
 385         unsigned long dma_size;
 386         u16 lead = 0, tail = 0;
 387
 388         if (info->state != FBINFO_STATE_RUNNING)
 389                 return -EPERM;
 390
 391         total_size = info->screen_size;
 392
 393         if (total_size == 0)
 394                 total_size = info->fix.smem_len;
 395
 396         if (p > total_size)
 397                 return -EFBIG;
 398
 399         if (count > total_size) {
 400                 err = -EFBIG;
 401                 count = total_size;
 402         }
 403
 404         if (count + p > total_size) {
 405                 if (!err)
 406                         err = -ENOSPC;
 407                 count = total_size - p;
 408         }
 409
 410         dst = (void __force *) (info->screen_base + p);
 411
 412         if (info->fbops->fb_sync)
 413                 info->fbops->fb_sync(info);
 414
 415         /* If transfer size > threshold and both src/dst
 416         addresses are aligned, use DMA */
 417         if (count >= 4096 &&
 418             ((unsigned long)buf & 3) == ((unsigned long)dst & 3)) {
 419                 /* Odd address = can't DMA. Align */
 420                 if ((unsigned long)dst & 3) {
 421                         lead = 4 - ((unsigned long)dst & 3);
 422                         if (copy_from_user(dst, buf, lead))
 423                                 return -EFAULT;
 424                         buf += lead;
 425                         dst += lead;
 426                 }
 427                 /* DMA resolution is 32 bits */
 428                 if ((count - lead) & 3)
 429                         tail = (count - lead) & 3;
 430                 /* DMA the data */
 431                 dma_size = count - lead - tail;
 432                 dma_err = ivtvfb_prep_dec_dma_to_device(itv,
 433                        p + lead + dma_offset, (void __user *)buf, dma_size);
 434                 if (dma_err)
 435                         return dma_err;
 436                 dst += dma_size;
 437                 buf += dma_size;
 438                 /* Copy any leftover data */
 439                 if (tail && copy_from_user(dst, buf, tail))
 440                         return -EFAULT;
 441         } else if (copy_from_user(dst, buf, count)) {
 442                 return -EFAULT;
 443         }
 444
 445         if  (!err)
 446                 *ppos += count;
 447
 448         return (err) ? err : count;
 449 }
 450
 451 static int ivtvfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
 452 {
 453         DEFINE_WAIT(wait);
 454         struct ivtv *itv = (struct ivtv *)info->par;
 455         int rc = 0;
 456
 457         switch (cmd) {
 458                 case FBIOGET_VBLANK: {
 459                         struct fb_vblank vblank;
 460                         u32 trace;
 461
 462                         memset(&vblank, 0, sizeof(struct fb_vblank));
 463
 464                         vblank.flags = FB_VBLANK_HAVE_COUNT |FB_VBLANK_HAVE_VCOUNT |
 465                                         FB_VBLANK_HAVE_VSYNC;
 466                         trace = read_reg(IVTV_REG_DEC_LINE_FIELD) >> 16;
 467                         if (itv->is_out_50hz && trace > 312)
 468                                 trace -= 312;
 469                         else if (itv->is_out_60hz && trace > 262)
 470                                 trace -= 262;
 471                         if (trace == 1)
 472                                 vblank.flags |= FB_VBLANK_VSYNCING;
 473                         vblank.count = itv->last_vsync_field;
 474                         vblank.vcount = trace;
 475                         vblank.hcount = 0;
 476                         if (copy_to_user((void __user *)arg, &vblank, sizeof(vblank)))
 477                                 return -EFAULT;
 478                         return 0;
 479                 }
 480
 481                 case FBIO_WAITFORVSYNC:
 482                         prepare_to_wait(&itv->vsync_waitq, &wait, TASK_INTERRUPTIBLE);
 483                         if (!schedule_timeout(msecs_to_jiffies(50)))
 484                                 rc = -ETIMEDOUT;
 485                         finish_wait(&itv->vsync_waitq, &wait);
 486                         return rc;
 487
 488                 case IVTVFB_IOC_DMA_FRAME: {
 489                         struct ivtvfb_dma_frame args;
 490
 491                         IVTVFB_DEBUG_INFO("IVTVFB_IOC_DMA_FRAME\n");
 492                         if (copy_from_user(&args, (void __user *)arg, sizeof(args)))
 493                                 return -EFAULT;
 494
 495                         return ivtvfb_prep_frame(itv, cmd, args.source, args.dest_offset, args.count);
 496                 }
 497
 498                 default:
 499                         IVTVFB_DEBUG_INFO("Unknown ioctl %08x\n", cmd);
 500                         return -EINVAL;
 501         }
 502         return 0;
 503 }
 504
 505 /* Framebuffer device handling */
 506
 507 static int ivtvfb_set_var(struct ivtv *itv, struct fb_var_screeninfo *var)
 508 {
 509         struct osd_info *oi = itv->osd_info;
 510         struct ivtv_osd_coords ivtv_osd;
 511         struct v4l2_rect ivtv_window;
 512         int osd_mode = -1;
 513
 514         IVTVFB_DEBUG_INFO("ivtvfb_set_var\n");
 515
 516         /* Select color space */
 517         if (var->nonstd) /* YUV */
 518                 write_reg(read_reg(0x02a00) | 0x0002000, 0x02a00);
 519         else /* RGB  */
 520                 write_reg(read_reg(0x02a00) & ~0x0002000, 0x02a00);
 521
 522         /* Set the color mode */
 523         switch (var->bits_per_pixel) {
 524                 case 8:
 525                         osd_mode = IVTV_OSD_BPP_8;
 526                         break;
 527                 case 32:
 528                         osd_mode = IVTV_OSD_BPP_32;
 529                         break;
 530                 case 16:
 531                         switch (var->green.length) {
 532                         case 4:
 533                                 osd_mode = IVTV_OSD_BPP_16_444;
 534                                 break;
 535                         case 5:
 536                                 osd_mode = IVTV_OSD_BPP_16_555;
 537                                 break;
 538                         case 6:
 539                                 osd_mode = IVTV_OSD_BPP_16_565;
 540                                 break;
 541                         default:
 542                                 IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid bpp\n");
 543                         }
 544                         break;
 545                 default:
 546                         IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid bpp\n");
 547         }
 548
 549         /* Set video mode. Although rare, the display can become scrambled even
 550            if we don't change mode. Always 'bounce' to osd_mode via mode 0 */
 551         if (osd_mode != -1) {
 552                 ivtv_vapi(itv, CX2341X_OSD_SET_PIXEL_FORMAT, 1, 0);
 553                 ivtv_vapi(itv, CX2341X_OSD_SET_PIXEL_FORMAT, 1, osd_mode);
 554         }
 555
 556         oi->bits_per_pixel = var->bits_per_pixel;
 557         oi->bytes_per_pixel = var->bits_per_pixel / 8;
 558
 559         /* Set the flicker filter */
 560         switch (var->vmode & FB_VMODE_MASK) {
 561                 case FB_VMODE_NONINTERLACED: /* Filter on */
 562                         ivtv_vapi(itv, CX2341X_OSD_SET_FLICKER_STATE, 1, 1);
 563                         break;
 564                 case FB_VMODE_INTERLACED: /* Filter off */
 565                         ivtv_vapi(itv, CX2341X_OSD_SET_FLICKER_STATE, 1, 0);
 566                         break;
 567                 default:
 568                         IVTVFB_DEBUG_WARN("ivtvfb_set_var - Invalid video mode\n");
 569         }
 570
 571         /* Read the current osd info */
 572         ivtvfb_get_osd_coords(itv, &ivtv_osd);
 573
 574         /* Now set the OSD to the size we want */
 575         ivtv_osd.pixel_stride = var->xres_virtual;
 576         ivtv_osd.lines = var->yres_virtual;
 577         ivtv_osd.x = 0;
 578         ivtv_osd.y = 0;
 579         ivtvfb_set_osd_coords(itv, &ivtv_osd);
 580
 581         /* Can't seem to find the right API combo for this.
 582            Use another function which does what we need through direct register access. */
 583         ivtv_window.width = var->xres;
 584         ivtv_window.height = var->yres;
 585
 586         /* Minimum margin cannot be 0, as X won't allow such a mode */
 587         if (!var->upper_margin)
 588                 var->upper_margin++;
 589         if (!var->left_margin)
 590                 var->left_margin++;
 591         ivtv_window.top = var->upper_margin - 1;
 592         ivtv_window.left = var->left_margin - 1;
 593
 594         ivtvfb_set_display_window(itv, &ivtv_window);
 595
 596         /* Pass screen size back to yuv handler */
 597         itv->yuv_info.osd_full_w = ivtv_osd.pixel_stride;
 598         itv->yuv_info.osd_full_h = ivtv_osd.lines;
 599
 600         /* Force update of yuv registers */
 601         itv->yuv_info.yuv_forced_update = 1;
 602
 603         /* Keep a copy of these settings */
 604         memcpy(&oi->fbvar_cur, var, sizeof(oi->fbvar_cur));
 605
 606         IVTVFB_DEBUG_INFO("Display size: %dx%d (virtual %dx%d) @ %dbpp\n",
 607                       var->xres, var->yres,
 608                       var->xres_virtual, var->yres_virtual,
 609                       var->bits_per_pixel);
 610
 611         IVTVFB_DEBUG_INFO("Display position: %d, %d\n",
 612                       var->left_margin, var->upper_margin);
 613
 614         IVTVFB_DEBUG_INFO("Display filter: %s\n",
 615                         (var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED ? "on" : "off");
 616         IVTVFB_DEBUG_INFO("Color space: %s\n", var->nonstd ? "YUV" : "RGB");
 617
 618         return 0;
 619 }
 620
 621 static int ivtvfb_get_fix(struct ivtv *itv, struct fb_fix_screeninfo *fix)
 622 {
 623         struct osd_info *oi = itv->osd_info;
 624
 625         IVTVFB_DEBUG_INFO("ivtvfb_get_fix\n");
 626         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
 627         strlcpy(fix->id, "cx23415 TV out", sizeof(fix->id));
 628         fix->smem_start = oi->video_pbase;
 629         fix->smem_len = oi->video_buffer_size;
 630         fix->type = FB_TYPE_PACKED_PIXELS;
 631         fix->visual = (oi->bits_per_pixel == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
 632         fix->xpanstep = 1;
 633         fix->ypanstep = 1;
 634         fix->ywrapstep = 0;
 635         fix->line_length = oi->display_byte_stride;
 636         fix->accel = FB_ACCEL_NONE;
 637         return 0;
 638 }
 639
 640 /* Check the requested display mode, returning -EINVAL if we can't
 641    handle it. */
 642
 643 static int _ivtvfb_check_var(struct fb_var_screeninfo *var, struct ivtv *itv)
 644 {
 645         struct osd_info *oi = itv->osd_info;
 646         int osd_height_limit;
 647         u32 pixclock, hlimit, vlimit;
 648
 649         IVTVFB_DEBUG_INFO("ivtvfb_check_var\n");
 650
 651         /* Set base references for mode calcs. */
 652         if (itv->is_out_50hz) {
 653                 pixclock = 84316;
 654                 hlimit = 776;
 655                 vlimit = 591;
 656                 osd_height_limit = 576;
 657         }
 658         else {
 659                 pixclock = 83926;
 660                 hlimit = 776;
 661                 vlimit = 495;
 662                 osd_height_limit = 480;
 663         }
 664
 665         if (var->bits_per_pixel == 8 || var->bits_per_pixel == 32) {
 666                 var->transp.offset = 24;
 667                 var->transp.length = 8;
 668                 var->red.offset = 16;
 669                 var->red.length = 8;
 670                 var->green.offset = 8;
 671                 var->green.length = 8;
 672                 var->blue.offset = 0;
 673                 var->blue.length = 8;
 674         }
 675         else if (var->bits_per_pixel == 16) {
 676                 /* To find out the true mode, check green length */
 677                 switch (var->green.length) {
 678                         case 4:
 679                                 var->red.offset = 8;
 680                                 var->red.length = 4;
 681                                 var->green.offset = 4;
 682                                 var->green.length = 4;
 683                                 var->blue.offset = 0;
 684                                 var->blue.length = 4;
 685                                 var->transp.offset = 12;
 686                                 var->transp.length = 1;
 687                                 break;
 688                         case 5:
 689                                 var->red.offset = 10;
 690                                 var->red.length = 5;
 691                                 var->green.offset = 5;
 692                                 var->green.length = 5;
 693                                 var->blue.offset = 0;
 694                                 var->blue.length = 5;
 695                                 var->transp.offset = 15;
 696                                 var->transp.length = 1;
 697                                 break;
 698                         default:
 699                                 var->red.offset = 11;
 700                                 var->red.length = 5;
 701                                 var->green.offset = 5;
 702                                 var->green.length = 6;
 703                                 var->blue.offset = 0;
 704                                 var->blue.length = 5;
 705                                 var->transp.offset = 0;
 706                                 var->transp.length = 0;
 707                                 break;
 708                 }
 709         }
 710         else {
 711                 IVTVFB_DEBUG_WARN("Invalid colour mode: %d\n", var->bits_per_pixel);
 712                 return -EINVAL;
 713         }
 714
 715         /* Check the resolution */
 716         if (var->xres > IVTV_OSD_MAX_WIDTH || var->yres > osd_height_limit) {
 717                 IVTVFB_DEBUG_WARN("Invalid resolution: %dx%d\n",
 718                                 var->xres, var->yres);
 719                 return -EINVAL;
 720         }
 721
 722         /* Max horizontal size is 1023 @ 32bpp, 2046 & 16bpp, 4092 @ 8bpp */
 723         if (var->xres_virtual > 4095 / (var->bits_per_pixel / 8) ||
 724             var->xres_virtual * var->yres_virtual * (var->bits_per_pixel / 8) > oi->video_buffer_size ||
 725             var->xres_virtual < var->xres ||
 726             var->yres_virtual < var->yres) {
 727                 IVTVFB_DEBUG_WARN("Invalid virtual resolution: %dx%d\n",
 728                         var->xres_virtual, var->yres_virtual);
 729                 return -EINVAL;
 730         }
 731
 732         /* Some extra checks if in 8 bit mode */
 733         if (var->bits_per_pixel == 8) {
 734                 /* Width must be a multiple of 4 */
 735                 if (var->xres & 3) {
 736                         IVTVFB_DEBUG_WARN("Invalid resolution for 8bpp: %d\n", var->xres);
 737                         return -EINVAL;
 738                 }
 739                 if (var->xres_virtual & 3) {
 740                         IVTVFB_DEBUG_WARN("Invalid virtual resolution for 8bpp: %d)\n", var->xres_virtual);
 741                         return -EINVAL;
 742                 }
 743         }
 744         else if (var->bits_per_pixel == 16) {
 745                 /* Width must be a multiple of 2 */
 746                 if (var->xres & 1) {
 747                         IVTVFB_DEBUG_WARN("Invalid resolution for 16bpp: %d\n", var->xres);
 748                         return -EINVAL;
 749                 }
 750                 if (var->xres_virtual & 1) {
 751                         IVTVFB_DEBUG_WARN("Invalid virtual resolution for 16bpp: %d)\n", var->xres_virtual);
 752                         return -EINVAL;
 753                 }
 754         }
 755
 756         /* Now check the offsets */
 757         if (var->xoffset >= var->xres_virtual || var->yoffset >= var->yres_virtual) {
 758                 IVTVFB_DEBUG_WARN("Invalid offset: %d (%d) %d (%d)\n",
 759                         var->xoffset, var->xres_virtual, var->yoffset, var->yres_virtual);
 760                 return -EINVAL;
 761         }
 762
 763         /* Check pixel format */
 764         if (var->nonstd > 1) {
 765                 IVTVFB_DEBUG_WARN("Invalid nonstd % d\n", var->nonstd);
 766                 return -EINVAL;
 767         }
 768
 769         /* Check video mode */
 770         if (((var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED) &&
 771                 ((var->vmode & FB_VMODE_MASK) != FB_VMODE_INTERLACED)) {
 772                 IVTVFB_DEBUG_WARN("Invalid video mode: %d\n", var->vmode & FB_VMODE_MASK);
 773                 return -EINVAL;
 774         }
 775
 776         /* Check the left & upper margins
 777            If the margins are too large, just center the screen
 778            (enforcing margins causes too many problems) */
 779
 780         if (var->left_margin + var->xres > IVTV_OSD_MAX_WIDTH + 1)
 781                 var->left_margin = 1 + ((IVTV_OSD_MAX_WIDTH - var->xres) / 2);
 782
 783         if (var->upper_margin + var->yres > (itv->is_out_50hz ? 577 : 481))
 784                 var->upper_margin = 1 + (((itv->is_out_50hz ? 576 : 480) -
 785                         var->yres) / 2);
 786
 787         /* Maintain overall 'size' for a constant refresh rate */
 788         var->right_margin = hlimit - var->left_margin - var->xres;
 789         var->lower_margin = vlimit - var->upper_margin - var->yres;
 790
 791         /* Fixed sync times */
 792         var->hsync_len = 24;
 793         var->vsync_len = 2;
 794
 795         /* Non-interlaced / interlaced mode is used to switch the OSD filter
 796            on or off. Adjust the clock timings to maintain a constant
 797            vertical refresh rate. */
 798         if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED)
 799                 var->pixclock = pixclock / 2;
 800         else
 801                 var->pixclock = pixclock;
 802
 803         itv->osd_rect.width = var->xres;
 804         itv->osd_rect.height = var->yres;
 805
 806         IVTVFB_DEBUG_INFO("Display size: %dx%d (virtual %dx%d) @ %dbpp\n",
 807                       var->xres, var->yres,
 808                       var->xres_virtual, var->yres_virtual,
 809                       var->bits_per_pixel);
 810
 811         IVTVFB_DEBUG_INFO("Display position: %d, %d\n",
 812                       var->left_margin, var->upper_margin);
 813
 814         IVTVFB_DEBUG_INFO("Display filter: %s\n",
 815                         (var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED ? "on" : "off");
 816         IVTVFB_DEBUG_INFO("Color space: %s\n", var->nonstd ? "YUV" : "RGB");
 817         return 0;
 818 }
 819
 820 static int ivtvfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 821 {
 822         struct ivtv *itv = (struct ivtv *) info->par;
 823         IVTVFB_DEBUG_INFO("ivtvfb_check_var\n");
 824         return _ivtvfb_check_var(var, itv);
 825 }
 826
 827 static int ivtvfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 828 {
 829         u32 osd_pan_index;
 830         struct ivtv *itv = (struct ivtv *) info->par;
 831
 832         if (var->yoffset + info->var.yres > info->var.yres_virtual ||
 833             var->xoffset + info->var.xres > info->var.xres_virtual)
 834                 return -EINVAL;
 835
 836         osd_pan_index = var->yoffset * info->fix.line_length
 837                       + var->xoffset * info->var.bits_per_pixel / 8;
 838         write_reg(osd_pan_index, 0x02A0C);
 839
 840         /* Pass this info back the yuv handler */
 841         itv->yuv_info.osd_x_pan = var->xoffset;
 842         itv->yuv_info.osd_y_pan = var->yoffset;
 843         /* Force update of yuv registers */
 844         itv->yuv_info.yuv_forced_update = 1;
 845         /* Remember this value */
 846         itv->osd_info->pan_cur = osd_pan_index;
 847         return 0;
 848 }
 849
 850 static int ivtvfb_set_par(struct fb_info *info)
 851 {
 852         int rc = 0;
 853         struct ivtv *itv = (struct ivtv *) info->par;
 854
 855         IVTVFB_DEBUG_INFO("ivtvfb_set_par\n");
 856
 857         rc = ivtvfb_set_var(itv, &info->var);
 858         ivtvfb_pan_display(&info->var, info);
 859         ivtvfb_get_fix(itv, &info->fix);
 860         ivtv_firmware_check(itv, "ivtvfb_set_par");
 861         return rc;
 862 }
 863
 864 static int ivtvfb_setcolreg(unsigned regno, unsigned red, unsigned green,
 865                                 unsigned blue, unsigned transp,
 866                                 struct fb_info *info)
 867 {
 868         u32 color, *palette;
 869         struct ivtv *itv = (struct ivtv *)info->par;
 870
 871         if (regno >= info->cmap.len)
 872                 return -EINVAL;
 873
 874         color = ((transp & 0xFF00) << 16) |((red & 0xFF00) << 8) | (green & 0xFF00) | ((blue & 0xFF00) >> 8);
 875         if (info->var.bits_per_pixel <= 8) {
 876                 write_reg(regno, 0x02a30);
 877                 write_reg(color, 0x02a34);
 878                 itv->osd_info->palette_cur[regno] = color;
 879                 return 0;
 880         }
 881         if (regno >= 16)
 882                 return -EINVAL;
 883
 884         palette = info->pseudo_palette;
 885         if (info->var.bits_per_pixel == 16) {
 886                 switch (info->var.green.length) {
 887                         case 4:
 888                                 color = ((red & 0xf000) >> 4) |
 889                                         ((green & 0xf000) >> 8) |
 890                                         ((blue & 0xf000) >> 12);
 891                                 break;
 892                         case 5:
 893                                 color = ((red & 0xf800) >> 1) |
 894                                         ((green & 0xf800) >> 6) |
 895                                         ((blue & 0xf800) >> 11);
 896                                 break;
 897                         case 6:
 898                                 color = (red & 0xf800 ) |
 899                                         ((green & 0xfc00) >> 5) |
 900                                         ((blue & 0xf800) >> 11);
 901                                 break;
 902                 }
 903         }
 904         palette[regno] = color;
 905         return 0;
 906 }
 907
 908 /* We don't really support blanking. All this does is enable or
 909    disable the OSD. */
 910 static int ivtvfb_blank(int blank_mode, struct fb_info *info)
 911 {
 912         struct ivtv *itv = (struct ivtv *)info->par;
 913
 914         IVTVFB_DEBUG_INFO("Set blanking mode : %d\n", blank_mode);
 915         switch (blank_mode) {
 916         case FB_BLANK_UNBLANK:
 917                 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, 1);
 918                 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 1);
 919                 break;
 920         case FB_BLANK_NORMAL:
 921         case FB_BLANK_HSYNC_SUSPEND:
 922         case FB_BLANK_VSYNC_SUSPEND:
 923                 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, 0);
 924                 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 1);
 925                 break;
 926         case FB_BLANK_POWERDOWN:
 927                 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
 928                 ivtv_vapi(itv, CX2341X_OSD_SET_STATE, 1, 0);
 929                 break;
 930         }
 931         itv->osd_info->blank_cur = blank_mode;
 932         return 0;
 933 }
 934
 935 static struct fb_ops ivtvfb_ops = {
 936         .owner = THIS_MODULE,
 937         .fb_write       = ivtvfb_write,
 938         .fb_check_var   = ivtvfb_check_var,
 939         .fb_set_par     = ivtvfb_set_par,
 940         .fb_setcolreg   = ivtvfb_setcolreg,
 941         .fb_fillrect    = cfb_fillrect,
 942         .fb_copyarea    = cfb_copyarea,
 943         .fb_imageblit   = cfb_imageblit,
 944         .fb_cursor      = NULL,
 945         .fb_ioctl       = ivtvfb_ioctl,
 946         .fb_pan_display = ivtvfb_pan_display,
 947         .fb_blank       = ivtvfb_blank,
 948 };
 949
 950 /* Restore hardware after firmware restart */
 951 static void ivtvfb_restore(struct ivtv *itv)
 952 {
 953         struct osd_info *oi = itv->osd_info;
 954         int i;
 955
 956         ivtvfb_set_var(itv, &oi->fbvar_cur);
 957         ivtvfb_blank(oi->blank_cur, &oi->ivtvfb_info);
 958         for (i = 0; i < 256; i++) {
 959                 write_reg(i, 0x02a30);
 960                 write_reg(oi->palette_cur[i], 0x02a34);
 961         }
 962         write_reg(oi->pan_cur, 0x02a0c);
 963 }
 964
 965 /* Initialization */
 966
 967
 968 /* Setup our initial video mode */
 969 static int ivtvfb_init_vidmode(struct ivtv *itv)
 970 {
 971         struct osd_info *oi = itv->osd_info;
 972         struct v4l2_rect start_window;
 973         int max_height;
 974
 975         /* Color mode */
 976
 977         if (osd_depth != 8 && osd_depth != 16 && osd_depth != 32)
 978                 osd_depth = 8;
 979         oi->bits_per_pixel = osd_depth;
 980         oi->bytes_per_pixel = oi->bits_per_pixel / 8;
 981
 982         /* Horizontal size & position */
 983
 984         if (osd_xres > 720)
 985                 osd_xres = 720;
 986
 987         /* Must be a multiple of 4 for 8bpp & 2 for 16bpp */
 988         if (osd_depth == 8)
 989                 osd_xres &= ~3;
 990         else if (osd_depth == 16)
 991                 osd_xres &= ~1;
 992
 993         start_window.width = osd_xres ? osd_xres : 640;
 994
 995         /* Check horizontal start (osd_left). */
 996         if (osd_left && osd_left + start_window.width > 721) {
 997                 IVTVFB_ERR("Invalid osd_left - assuming default\n");
 998                 osd_left = 0;
 999         }
1000
1001         /* Hardware coords start at 0, user coords start at 1. */
1002         osd_left--;
1003
1004         start_window.left = osd_left >= 0 ?
1005                  osd_left : ((IVTV_OSD_MAX_WIDTH - start_window.width) / 2);
1006
1007         oi->display_byte_stride =
1008                         start_window.width * oi->bytes_per_pixel;
1009
1010         /* Vertical size & position */
1011
1012         max_height = itv->is_out_50hz ? 576 : 480;
1013
1014         if (osd_yres > max_height)
1015                 osd_yres = max_height;
1016
1017         start_window.height = osd_yres ?
1018                 osd_yres : itv->is_out_50hz ? 480 : 400;
1019
1020         /* Check vertical start (osd_upper). */
1021         if (osd_upper + start_window.height > max_height + 1) {
1022                 IVTVFB_ERR("Invalid osd_upper - assuming default\n");
1023                 osd_upper = 0;
1024         }
1025
1026         /* Hardware coords start at 0, user coords start at 1. */
1027         osd_upper--;
1028
1029         start_window.top = osd_upper >= 0 ? osd_upper : ((max_height - start_window.height) / 2);
1030
1031         oi->display_width = start_window.width;
1032         oi->display_height = start_window.height;
1033
1034         /* Generate a valid fb_var_screeninfo */
1035
1036         oi->ivtvfb_defined.xres = oi->display_width;
1037         oi->ivtvfb_defined.yres = oi->display_height;
1038         oi->ivtvfb_defined.xres_virtual = oi->display_width;
1039         oi->ivtvfb_defined.yres_virtual = oi->display_height;
1040         oi->ivtvfb_defined.bits_per_pixel = oi->bits_per_pixel;
1041         oi->ivtvfb_defined.vmode = (osd_laced ? FB_VMODE_INTERLACED : FB_VMODE_NONINTERLACED);
1042         oi->ivtvfb_defined.left_margin = start_window.left + 1;
1043         oi->ivtvfb_defined.upper_margin = start_window.top + 1;
1044         oi->ivtvfb_defined.accel_flags = FB_ACCEL_NONE;
1045         oi->ivtvfb_defined.nonstd = 0;
1046
1047         /* We've filled in the most data, let the usual mode check
1048            routine fill in the rest. */
1049         _ivtvfb_check_var(&oi->ivtvfb_defined, itv);
1050
1051         /* Generate valid fb_fix_screeninfo */
1052
1053         ivtvfb_get_fix(itv, &oi->ivtvfb_fix);
1054
1055         /* Generate valid fb_info */
1056
1057         oi->ivtvfb_info.node = -1;
1058         oi->ivtvfb_info.flags = FBINFO_FLAG_DEFAULT;
1059         oi->ivtvfb_info.fbops = &ivtvfb_ops;
1060         oi->ivtvfb_info.par = itv;
1061         oi->ivtvfb_info.var = oi->ivtvfb_defined;
1062         oi->ivtvfb_info.fix = oi->ivtvfb_fix;
1063         oi->ivtvfb_info.screen_base = (u8 __iomem *)oi->video_vbase;
1064         oi->ivtvfb_info.fbops = &ivtvfb_ops;
1065
1066         /* Supply some monitor specs. Bogus values will do for now */
1067         oi->ivtvfb_info.monspecs.hfmin = 8000;
1068         oi->ivtvfb_info.monspecs.hfmax = 70000;
1069         oi->ivtvfb_info.monspecs.vfmin = 10;
1070         oi->ivtvfb_info.monspecs.vfmax = 100;
1071
1072         /* Allocate color map */
1073         if (fb_alloc_cmap(&oi->ivtvfb_info.cmap, 256, 1)) {
1074                 IVTVFB_ERR("abort, unable to alloc cmap\n");
1075                 return -ENOMEM;
1076         }
1077
1078         /* Allocate the pseudo palette */
1079         oi->ivtvfb_info.pseudo_palette =
1080                 kmalloc_array(16, sizeof(u32), GFP_KERNEL|__GFP_NOWARN);
1081
1082         if (!oi->ivtvfb_info.pseudo_palette) {
1083                 IVTVFB_ERR("abort, unable to alloc pseudo palette\n");
1084                 return -ENOMEM;
1085         }
1086
1087         return 0;
1088 }
1089
1090 /* Find OSD buffer base & size. Add to mtrr. Zero osd buffer. */
1091
1092 static int ivtvfb_init_io(struct ivtv *itv)
1093 {
1094         struct osd_info *oi = itv->osd_info;
1095         /* Find the largest power of two that maps the whole buffer */
1096         int size_shift = 31;
1097
1098         mutex_lock(&itv->serialize_lock);
1099         if (ivtv_init_on_first_open(itv)) {
1100                 mutex_unlock(&itv->serialize_lock);
1101                 IVTVFB_ERR("Failed to initialize ivtv\n");
1102                 return -ENXIO;
1103         }
1104         mutex_unlock(&itv->serialize_lock);
1105
1106         if (ivtvfb_get_framebuffer(itv, &oi->video_rbase,
1107                                         &oi->video_buffer_size) < 0) {
1108                 IVTVFB_ERR("Firmware failed to respond\n");
1109                 return -EIO;
1110         }
1111
1112         /* The osd buffer size depends on the number of video buffers allocated
1113            on the PVR350 itself. For now we'll hardcode the smallest osd buffer
1114            size to prevent any overlap. */
1115         oi->video_buffer_size = 1704960;
1116
1117         oi->video_pbase = itv->base_addr + IVTV_DECODER_OFFSET + oi->video_rbase;
1118         oi->video_vbase = itv->dec_mem + oi->video_rbase;
1119
1120         if (!oi->video_vbase) {
1121                 IVTVFB_ERR("abort, video memory 0x%x @ 0x%lx isn't mapped!\n",
1122                      oi->video_buffer_size, oi->video_pbase);
1123                 return -EIO;
1124         }
1125
1126         IVTVFB_INFO("Framebuffer at 0x%lx, mapped to 0x%p, size %dk\n",
1127                         oi->video_pbase, oi->video_vbase,
1128                         oi->video_buffer_size / 1024);
1129
1130         while (!(oi->video_buffer_size & (1 << size_shift)))
1131                 size_shift--;
1132         size_shift++;
1133         oi->fb_start_aligned_physaddr = oi->video_pbase & ~((1 << size_shift) - 1);
1134         oi->fb_end_aligned_physaddr = oi->video_pbase + oi->video_buffer_size;
1135         oi->fb_end_aligned_physaddr += (1 << size_shift) - 1;
1136         oi->fb_end_aligned_physaddr &= ~((1 << size_shift) - 1);
1137         oi->wc_cookie = arch_phys_wc_add(oi->fb_start_aligned_physaddr,
1138                                          oi->fb_end_aligned_physaddr -
1139                                          oi->fb_start_aligned_physaddr);
1140         /* Blank the entire osd. */
1141         memset_io(oi->video_vbase, 0, oi->video_buffer_size);
1142
1143         return 0;
1144 }
1145
1146 /* Release any memory we've grabbed & remove mtrr entry */
1147 static void ivtvfb_release_buffers (struct ivtv *itv)
1148 {
1149         struct osd_info *oi = itv->osd_info;
1150
1151         /* Release cmap */
1152         if (oi->ivtvfb_info.cmap.len)
1153                 fb_dealloc_cmap(&oi->ivtvfb_info.cmap);
1154
1155         /* Release pseudo palette */
1156         kfree(oi->ivtvfb_info.pseudo_palette);
1157         arch_phys_wc_del(oi->wc_cookie);
1158         kfree(oi);
1159         itv->osd_info = NULL;
1160 }
1161
1162 /* Initialize the specified card */
1163
1164 static int ivtvfb_init_card(struct ivtv *itv)
1165 {
1166         int rc;
1167
1168 #ifdef CONFIG_X86_64
1169         if (pat_enabled()) {
1170                 pr_warn("ivtvfb needs PAT disabled, boot with nopat kernel parameter\n");
1171                 return -ENODEV;
1172         }
1173 #endif
1174
1175         if (itv->osd_info) {
1176                 IVTVFB_ERR("Card %d already initialised\n", ivtvfb_card_id);
1177                 return -EBUSY;
1178         }
1179
1180         itv->osd_info = kzalloc(sizeof(struct osd_info),
1181                                         GFP_ATOMIC|__GFP_NOWARN);
1182         if (itv->osd_info == NULL) {
1183                 IVTVFB_ERR("Failed to allocate memory for osd_info\n");
1184                 return -ENOMEM;
1185         }
1186
1187         /* Find & setup the OSD buffer */
1188         rc = ivtvfb_init_io(itv);
1189         if (rc) {
1190                 ivtvfb_release_buffers(itv);
1191                 return rc;
1192         }
1193
1194         /* Set the startup video mode information */
1195         if ((rc = ivtvfb_init_vidmode(itv))) {
1196                 ivtvfb_release_buffers(itv);
1197                 return rc;
1198         }
1199
1200         /* Register the framebuffer */
1201         if (register_framebuffer(&itv->osd_info->ivtvfb_info) < 0) {
1202                 ivtvfb_release_buffers(itv);
1203                 return -EINVAL;
1204         }
1205
1206         itv->osd_video_pbase = itv->osd_info->video_pbase;
1207
1208         /* Set the card to the requested mode */
1209         ivtvfb_set_par(&itv->osd_info->ivtvfb_info);
1210
1211         /* Set color 0 to black */
1212         write_reg(0, 0x02a30);
1213         write_reg(0, 0x02a34);
1214
1215         /* Enable the osd */
1216         ivtvfb_blank(FB_BLANK_UNBLANK, &itv->osd_info->ivtvfb_info);
1217
1218         /* Enable restart */
1219         itv->ivtvfb_restore = ivtvfb_restore;
1220
1221         /* Allocate DMA */
1222         ivtv_udma_alloc(itv);
1223         return 0;
1224
1225 }
1226
1227 static int __init ivtvfb_callback_init(struct device *dev, void *p)
1228 {
1229         struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
1230         struct ivtv *itv = container_of(v4l2_dev, struct ivtv, v4l2_dev);
1231
1232         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1233                 if (ivtvfb_init_card(itv) == 0) {
1234                         IVTVFB_INFO("Framebuffer registered on %s\n",
1235                                         itv->v4l2_dev.name);
1236                         (*(int *)p)++;
1237                 }
1238         }
1239         return 0;
1240 }
1241
1242 static int ivtvfb_callback_cleanup(struct device *dev, void *p)
1243 {
1244         struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
1245         struct ivtv *itv = container_of(v4l2_dev, struct ivtv, v4l2_dev);
1246         struct osd_info *oi = itv->osd_info;
1247
1248         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1249                 if (unregister_framebuffer(&itv->osd_info->ivtvfb_info)) {
1250                         IVTVFB_WARN("Framebuffer %d is in use, cannot unload\n",
1251                                        itv->instance);
1252                         return 0;
1253                 }
1254                 IVTVFB_INFO("Unregister framebuffer %d\n", itv->instance);
1255                 itv->ivtvfb_restore = NULL;
1256                 ivtvfb_blank(FB_BLANK_VSYNC_SUSPEND, &oi->ivtvfb_info);
1257                 ivtvfb_release_buffers(itv);
1258                 itv->osd_video_pbase = 0;
1259         }
1260         return 0;
1261 }
1262
1263 static int __init ivtvfb_init(void)
1264 {
1265         struct device_driver *drv;
1266         int registered = 0;
1267         int err;
1268
1269
1270         if (ivtvfb_card_id < -1 || ivtvfb_card_id >= IVTV_MAX_CARDS) {
1271                 pr_err("ivtvfb_card_id parameter is out of range (valid range: -1 - %d)\n",
1272                      IVTV_MAX_CARDS - 1);
1273                 return -EINVAL;
1274         }
1275
1276         drv = driver_find("ivtv", &pci_bus_type);
1277         err = driver_for_each_device(drv, NULL, &registered, ivtvfb_callback_init);
1278         (void)err;      /* suppress compiler warning */
1279         if (!registered) {
1280                 pr_err("no cards found\n");
1281                 return -ENODEV;
1282         }
1283         return 0;
1284 }
1285
1286 static void ivtvfb_cleanup(void)
1287 {
1288         struct device_driver *drv;
1289         int err;
1290
1291         pr_info("Unloading framebuffer module\n");
1292
1293         drv = driver_find("ivtv", &pci_bus_type);
1294         err = driver_for_each_device(drv, NULL, NULL, ivtvfb_callback_cleanup);
1295         (void)err;      /* suppress compiler warning */
1296 }
1297
1298 module_init(ivtvfb_init);
1299 module_exit(ivtvfb_cleanup);