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