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