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