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