xref: /linux/drivers/media/pci/ivtv/ivtvfb.c (revision fa84cf094ef9667e2b91c104b0a788fd1896f482)
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);
1300