2 * controlfb.c -- frame buffer device for the PowerMac 'control' display
4 * Created 12 July 1998 by Dan Jacobowitz <dan@debian.org>
5 * Copyright (C) 1998 Dan Jacobowitz
6 * Copyright (C) 2001 Takashi Oe
8 * Mmap code by Michel Lanners <mlan@cpu.lu>
10 * Frame buffer structure from:
11 * drivers/video/chipsfb.c -- frame buffer device for
12 * Chips & Technologies 65550 chip.
14 * Copyright (C) 1998 Paul Mackerras
16 * This file is derived from the Powermac "chips" driver:
17 * Copyright (C) 1997 Fabio Riccardi.
18 * And from the frame buffer device for Open Firmware-initialized devices:
19 * Copyright (C) 1997 Geert Uytterhoeven.
21 * Hardware information from:
22 * control.c: Console support for PowerMac "control" display adaptor.
23 * Copyright (C) 1996 Paul Mackerras
25 * Updated to 2.5 framebuffer API by Ben Herrenschmidt
26 * <benh@kernel.crashing.org>, Paul Mackerras <paulus@samba.org>,
27 * and James Simmons <jsimmons@infradead.org>.
29 * This file is subject to the terms and conditions of the GNU General Public
30 * License. See the file COPYING in the main directory of this archive for
34 #include <linux/module.h>
35 #include <linux/kernel.h>
36 #include <linux/errno.h>
37 #include <linux/string.h>
39 #include <linux/slab.h>
40 #include <linux/vmalloc.h>
41 #include <linux/delay.h>
42 #include <linux/interrupt.h>
44 #include <linux/init.h>
45 #include <linux/pci.h>
46 #include <linux/nvram.h>
47 #include <linux/adb.h>
48 #include <linux/cuda.h>
51 #include <asm/pgtable.h>
52 #include <asm/btext.h>
55 #include "controlfb.h"
57 struct fb_par_control
{
63 struct control_regvals regvals
;
68 #define DIRTY(z) ((x)->z != (y)->z)
69 #define DIRTY_CMAP(z) (memcmp(&((x)->z), &((y)->z), sizeof((y)->z)))
70 static inline int PAR_EQUAL(struct fb_par_control
*x
, struct fb_par_control
*y
)
75 for (i
= 0; i
< 3; i
++)
76 results
&= !DIRTY(regvals
.clock_params
[i
]);
79 for (i
= 0; i
< 16; i
++)
80 results
&= !DIRTY(regvals
.regs
[i
]);
83 return (!DIRTY(cmode
) && !DIRTY(xres
) && !DIRTY(yres
)
84 && !DIRTY(vxres
) && !DIRTY(vyres
));
86 static inline int VAR_MATCH(struct fb_var_screeninfo
*x
, struct fb_var_screeninfo
*y
)
88 return (!DIRTY(bits_per_pixel
) && !DIRTY(xres
)
89 && !DIRTY(yres
) && !DIRTY(xres_virtual
)
90 && !DIRTY(yres_virtual
)
91 && !DIRTY_CMAP(red
) && !DIRTY_CMAP(green
) && !DIRTY_CMAP(blue
));
94 struct fb_info_control
{
96 struct fb_par_control par
;
97 u32 pseudo_palette
[17];
99 struct cmap_regs __iomem
*cmap_regs
;
100 unsigned long cmap_regs_phys
;
102 struct control_regs __iomem
*control_regs
;
103 unsigned long control_regs_phys
;
104 unsigned long control_regs_size
;
106 __u8 __iomem
*frame_buffer
;
107 unsigned long frame_buffer_phys
;
108 unsigned long fb_orig_base
;
109 unsigned long fb_orig_size
;
111 int control_use_bank2
;
112 unsigned long total_vram
;
113 unsigned char vram_attr
;
116 /* control register access macro */
117 #define CNTRL_REG(INFO,REG) (&(((INFO)->control_regs->REG).r))
120 /******************** Prototypes for exported functions ********************/
124 static int controlfb_pan_display(struct fb_var_screeninfo
*var
,
125 struct fb_info
*info
);
126 static int controlfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
127 u_int transp
, struct fb_info
*info
);
128 static int controlfb_blank(int blank_mode
, struct fb_info
*info
);
129 static int controlfb_mmap(struct fb_info
*info
,
130 struct vm_area_struct
*vma
);
131 static int controlfb_set_par (struct fb_info
*info
);
132 static int controlfb_check_var (struct fb_var_screeninfo
*var
, struct fb_info
*info
);
134 /******************** Prototypes for internal functions **********************/
136 static void set_control_clock(unsigned char *params
);
137 static int init_control(struct fb_info_control
*p
);
138 static void control_set_hardware(struct fb_info_control
*p
,
139 struct fb_par_control
*par
);
140 static int control_of_init(struct device_node
*dp
);
141 static void find_vram_size(struct fb_info_control
*p
);
142 static int read_control_sense(struct fb_info_control
*p
);
143 static int calc_clock_params(unsigned long clk
, unsigned char *param
);
144 static int control_var_to_par(struct fb_var_screeninfo
*var
,
145 struct fb_par_control
*par
, const struct fb_info
*fb_info
);
146 static inline void control_par_to_var(struct fb_par_control
*par
,
147 struct fb_var_screeninfo
*var
);
148 static void control_init_info(struct fb_info
*info
, struct fb_info_control
*p
);
149 static void control_cleanup(void);
152 /************************** Internal variables *******************************/
154 static struct fb_info_control
*control_fb
;
156 static int default_vmode __initdata
= VMODE_NVRAM
;
157 static int default_cmode __initdata
= CMODE_NVRAM
;
160 static struct fb_ops controlfb_ops
= {
161 .owner
= THIS_MODULE
,
162 .fb_check_var
= controlfb_check_var
,
163 .fb_set_par
= controlfb_set_par
,
164 .fb_setcolreg
= controlfb_setcolreg
,
165 .fb_pan_display
= controlfb_pan_display
,
166 .fb_blank
= controlfb_blank
,
167 .fb_mmap
= controlfb_mmap
,
168 .fb_fillrect
= cfb_fillrect
,
169 .fb_copyarea
= cfb_copyarea
,
170 .fb_imageblit
= cfb_imageblit
,
174 /******************** The functions for controlfb_ops ********************/
177 MODULE_LICENSE("GPL");
179 int init_module(void)
181 struct device_node
*dp
;
183 dp
= find_devices("control");
184 if (dp
!= 0 && !control_of_init(dp
))
190 void cleanup_module(void)
197 * Checks a var structure
199 static int controlfb_check_var (struct fb_var_screeninfo
*var
, struct fb_info
*info
)
201 struct fb_par_control par
;
204 err
= control_var_to_par(var
, &par
, info
);
207 control_par_to_var(&par
, var
);
213 * Applies current var to display
215 static int controlfb_set_par (struct fb_info
*info
)
217 struct fb_info_control
*p
= (struct fb_info_control
*) info
;
218 struct fb_par_control par
;
221 if((err
= control_var_to_par(&info
->var
, &par
, info
))) {
222 printk (KERN_ERR
"controlfb_set_par: error calling"
223 " control_var_to_par: %d.\n", err
);
227 control_set_hardware(p
, &par
);
229 info
->fix
.visual
= (p
->par
.cmode
== CMODE_8
) ?
230 FB_VISUAL_PSEUDOCOLOR
: FB_VISUAL_DIRECTCOLOR
;
231 info
->fix
.line_length
= p
->par
.pitch
;
232 info
->fix
.xpanstep
= 32 >> p
->par
.cmode
;
233 info
->fix
.ypanstep
= 1;
239 * Set screen start address according to var offset values
241 static inline void set_screen_start(int xoffset
, int yoffset
,
242 struct fb_info_control
*p
)
244 struct fb_par_control
*par
= &p
->par
;
246 par
->xoffset
= xoffset
;
247 par
->yoffset
= yoffset
;
248 out_le32(CNTRL_REG(p
,start_addr
),
249 par
->yoffset
* par
->pitch
+ (par
->xoffset
<< par
->cmode
));
253 static int controlfb_pan_display(struct fb_var_screeninfo
*var
,
254 struct fb_info
*info
)
256 unsigned int xoffset
, hstep
;
257 struct fb_info_control
*p
= (struct fb_info_control
*)info
;
258 struct fb_par_control
*par
= &p
->par
;
261 * make sure start addr will be 32-byte aligned
263 hstep
= 0x1f >> par
->cmode
;
264 xoffset
= (var
->xoffset
+ hstep
) & ~hstep
;
266 if (xoffset
+par
->xres
> par
->vxres
||
267 var
->yoffset
+par
->yres
> par
->vyres
)
270 set_screen_start(xoffset
, var
->yoffset
, p
);
277 * Private mmap since we want to have a different caching on the framebuffer
279 * Note there's no locking in here; it's done in fb_mmap() in fbmem.c.
281 static int controlfb_mmap(struct fb_info
*info
,
282 struct vm_area_struct
*vma
)
284 unsigned long off
, start
;
287 off
= vma
->vm_pgoff
<< PAGE_SHIFT
;
289 /* frame buffer memory */
290 start
= info
->fix
.smem_start
;
291 len
= PAGE_ALIGN((start
& ~PAGE_MASK
)+info
->fix
.smem_len
);
293 /* memory mapped io */
295 if (info
->var
.accel_flags
)
297 start
= info
->fix
.mmio_start
;
298 len
= PAGE_ALIGN((start
& ~PAGE_MASK
)+info
->fix
.mmio_len
);
299 pgprot_val(vma
->vm_page_prot
) |= _PAGE_NO_CACHE
|_PAGE_GUARDED
;
302 pgprot_val(vma
->vm_page_prot
) |= _PAGE_WRITETHRU
;
305 if ((vma
->vm_end
- vma
->vm_start
+ off
) > len
)
308 vma
->vm_pgoff
= off
>> PAGE_SHIFT
;
309 if (io_remap_pfn_range(vma
, vma
->vm_start
, off
>> PAGE_SHIFT
,
310 vma
->vm_end
- vma
->vm_start
, vma
->vm_page_prot
))
316 static int controlfb_blank(int blank_mode
, struct fb_info
*info
)
318 struct fb_info_control
*p
= (struct fb_info_control
*) info
;
321 ctrl
= ld_le32(CNTRL_REG(p
,ctrl
));
323 switch (blank_mode
) {
324 case FB_BLANK_VSYNC_SUSPEND
:
327 case FB_BLANK_HSYNC_SUSPEND
:
330 case FB_BLANK_POWERDOWN
:
333 case FB_BLANK_NORMAL
:
343 out_le32(CNTRL_REG(p
,ctrl
), ctrl
);
348 static int controlfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
349 u_int transp
, struct fb_info
*info
)
351 struct fb_info_control
*p
= (struct fb_info_control
*) info
;
361 out_8(&p
->cmap_regs
->addr
, regno
); /* tell clut what addr to fill */
362 out_8(&p
->cmap_regs
->lut
, r
); /* send one color channel at */
363 out_8(&p
->cmap_regs
->lut
, g
); /* a time... */
364 out_8(&p
->cmap_regs
->lut
, b
);
368 switch (p
->par
.cmode
) {
370 p
->pseudo_palette
[regno
] =
371 (regno
<< 10) | (regno
<< 5) | regno
;
374 i
= (regno
<< 8) | regno
;
375 p
->pseudo_palette
[regno
] = (i
<< 16) | i
;
384 /******************** End of controlfb_ops implementation ******************/
388 static void set_control_clock(unsigned char *params
)
390 #ifdef CONFIG_ADB_CUDA
391 struct adb_request req
;
394 for (i
= 0; i
< 3; ++i
) {
395 cuda_request(&req
, NULL
, 5, CUDA_PACKET
, CUDA_GET_SET_IIC
,
396 0x50, i
+ 1, params
[i
]);
397 while (!req
.complete
)
405 * finish off the driver initialization and register
407 static int __init
init_control(struct fb_info_control
*p
)
409 int full
, sense
, vmode
, cmode
, vyres
;
410 struct fb_var_screeninfo var
;
413 printk(KERN_INFO
"controlfb: ");
415 full
= p
->total_vram
== 0x400000;
417 /* Try to pick a video mode out of NVRAM if we have one. */
419 if (default_cmode
== CMODE_NVRAM
){
420 cmode
= nvram_read_byte(NV_CMODE
);
421 if(cmode
< CMODE_8
|| cmode
> CMODE_32
)
427 if (default_vmode
== VMODE_NVRAM
) {
428 vmode
= nvram_read_byte(NV_VMODE
);
429 if (vmode
< 1 || vmode
> VMODE_MAX
||
430 control_mac_modes
[vmode
- 1].m
[full
] < cmode
) {
431 sense
= read_control_sense(p
);
432 printk("Monitor sense value = 0x%x, ", sense
);
433 vmode
= mac_map_monitor_sense(sense
);
434 if (control_mac_modes
[vmode
- 1].m
[full
] < cmode
)
435 vmode
= VMODE_640_480_60
;
441 if (control_mac_modes
[vmode
- 1].m
[full
] < cmode
) {
445 vmode
= VMODE_640_480_60
;
449 /* Initialize info structure */
450 control_init_info(&p
->info
, p
);
452 /* Setup default var */
453 if (mac_vmode_to_var(vmode
, cmode
, &var
) < 0) {
454 /* This shouldn't happen! */
455 printk("mac_vmode_to_var(%d, %d,) failed\n", vmode
, cmode
);
457 vmode
= VMODE_640_480_60
;
459 if (mac_vmode_to_var(vmode
, cmode
, &var
) < 0) {
460 printk(KERN_ERR
"controlfb: mac_vmode_to_var() failed\n");
463 printk(KERN_INFO
"controlfb: ");
465 printk("using video mode %d and color mode %d.\n", vmode
, cmode
);
467 vyres
= (p
->total_vram
- CTRLFB_OFF
) / (var
.xres
<< cmode
);
468 if (vyres
> var
.yres
)
469 var
.yres_virtual
= vyres
;
471 /* Apply default var */
472 var
.activate
= FB_ACTIVATE_NOW
;
473 rc
= fb_set_var(&p
->info
, &var
);
474 if (rc
&& (vmode
!= VMODE_640_480_60
|| cmode
!= CMODE_8
))
477 /* Register with fbdev layer */
478 if (register_framebuffer(&p
->info
) < 0)
481 printk(KERN_INFO
"fb%d: control display adapter\n", p
->info
.node
);
486 #define RADACAL_WRITE(a,d) \
487 out_8(&p->cmap_regs->addr, (a)); \
488 out_8(&p->cmap_regs->dat, (d))
490 /* Now how about actually saying, Make it so! */
491 /* Some things in here probably don't need to be done each time. */
492 static void control_set_hardware(struct fb_info_control
*p
, struct fb_par_control
*par
)
494 struct control_regvals
*r
;
495 volatile struct preg __iomem
*rp
;
498 if (PAR_EQUAL(&p
->par
, par
)) {
500 * check if only xoffset or yoffset differs.
501 * this prevents flickers in typical VT switch case.
503 if (p
->par
.xoffset
!= par
->xoffset
||
504 p
->par
.yoffset
!= par
->yoffset
)
505 set_screen_start(par
->xoffset
, par
->yoffset
, p
);
511 cmode
= p
->par
.cmode
;
514 /* Turn off display */
515 out_le32(CNTRL_REG(p
,ctrl
), 0x400 | par
->ctrl
);
517 set_control_clock(r
->clock_params
);
519 RADACAL_WRITE(0x20, r
->radacal_ctrl
);
520 RADACAL_WRITE(0x21, p
->control_use_bank2
? 0 : 1);
521 RADACAL_WRITE(0x10, 0);
522 RADACAL_WRITE(0x11, 0);
524 rp
= &p
->control_regs
->vswin
;
525 for (i
= 0; i
< 16; ++i
, ++rp
)
526 out_le32(&rp
->r
, r
->regs
[i
]);
528 out_le32(CNTRL_REG(p
,pitch
), par
->pitch
);
529 out_le32(CNTRL_REG(p
,mode
), r
->mode
);
530 out_le32(CNTRL_REG(p
,vram_attr
), p
->vram_attr
);
531 out_le32(CNTRL_REG(p
,start_addr
), par
->yoffset
* par
->pitch
532 + (par
->xoffset
<< cmode
));
533 out_le32(CNTRL_REG(p
,rfrcnt
), 0x1e5);
534 out_le32(CNTRL_REG(p
,intr_ena
), 0);
536 /* Turn on display */
537 out_le32(CNTRL_REG(p
,ctrl
), par
->ctrl
);
539 #ifdef CONFIG_BOOTX_TEXT
540 btext_update_display(p
->frame_buffer_phys
+ CTRLFB_OFF
,
541 p
->par
.xres
, p
->par
.yres
,
542 (cmode
== CMODE_32
? 32: cmode
== CMODE_16
? 16: 8),
544 #endif /* CONFIG_BOOTX_TEXT */
549 * Parse user speficied options (`video=controlfb:')
551 static void __init
control_setup(char *options
)
555 if (!options
|| !*options
)
558 while ((this_opt
= strsep(&options
, ",")) != NULL
) {
559 if (!strncmp(this_opt
, "vmode:", 6)) {
560 int vmode
= simple_strtoul(this_opt
+6, NULL
, 0);
561 if (vmode
> 0 && vmode
<= VMODE_MAX
&&
562 control_mac_modes
[vmode
- 1].m
[1] >= 0)
563 default_vmode
= vmode
;
564 } else if (!strncmp(this_opt
, "cmode:", 6)) {
565 int depth
= simple_strtoul(this_opt
+6, NULL
, 0);
570 default_cmode
= depth
;
573 default_cmode
= CMODE_8
;
577 default_cmode
= CMODE_16
;
581 default_cmode
= CMODE_32
;
588 static int __init
control_init(void)
590 struct device_node
*dp
;
593 if (fb_get_options("controlfb", &option
))
595 control_setup(option
);
597 dp
= find_devices("control");
598 if (dp
!= 0 && !control_of_init(dp
))
604 module_init(control_init
);
606 /* Work out which banks of VRAM we have installed. */
607 /* danj: I guess the card just ignores writes to nonexistant VRAM... */
609 static void __init
find_vram_size(struct fb_info_control
*p
)
614 * Set VRAM in 2MB (bank 1) mode
615 * VRAM Bank 2 will be accessible through offset 0x600000 if present
616 * and VRAM Bank 1 will not respond at that offset even if present
618 out_le32(CNTRL_REG(p
,vram_attr
), 0x31);
620 out_8(&p
->frame_buffer
[0x600000], 0xb3);
621 out_8(&p
->frame_buffer
[0x600001], 0x71);
622 asm volatile("eieio; dcbf 0,%0" : : "r" (&p
->frame_buffer
[0x600000])
625 asm volatile("eieio; dcbi 0,%0" : : "r" (&p
->frame_buffer
[0x600000])
629 bank2
= (in_8(&p
->frame_buffer
[0x600000]) == 0xb3)
630 && (in_8(&p
->frame_buffer
[0x600001]) == 0x71);
633 * Set VRAM in 2MB (bank 2) mode
634 * VRAM Bank 1 will be accessible through offset 0x000000 if present
635 * and VRAM Bank 2 will not respond at that offset even if present
637 out_le32(CNTRL_REG(p
,vram_attr
), 0x39);
639 out_8(&p
->frame_buffer
[0], 0x5a);
640 out_8(&p
->frame_buffer
[1], 0xc7);
641 asm volatile("eieio; dcbf 0,%0" : : "r" (&p
->frame_buffer
[0])
644 asm volatile("eieio; dcbi 0,%0" : : "r" (&p
->frame_buffer
[0])
648 bank1
= (in_8(&p
->frame_buffer
[0]) == 0x5a)
649 && (in_8(&p
->frame_buffer
[1]) == 0xc7);
656 p
->control_use_bank2
= 1;
658 p
->frame_buffer
+= 0x600000;
659 p
->frame_buffer_phys
+= 0x600000;
673 p
->total_vram
= (bank1
+ bank2
) * 0x200000;
675 printk(KERN_INFO
"controlfb: VRAM Total = %dMB "
676 "(%dMB @ bank 1, %dMB @ bank 2)\n",
677 (bank1
+ bank2
) << 1, bank1
<< 1, bank2
<< 1);
682 * find "control" and initialize
684 static int __init
control_of_init(struct device_node
*dp
)
686 struct fb_info_control
*p
;
687 struct resource fb_res
, reg_res
;
690 printk(KERN_ERR
"controlfb: only one control is supported\n");
694 if (of_pci_address_to_resource(dp
, 2, &fb_res
) ||
695 of_pci_address_to_resource(dp
, 1, ®_res
)) {
696 printk(KERN_ERR
"can't get 2 addresses for control\n");
699 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
702 control_fb
= p
; /* save it for cleanups */
704 /* Map in frame buffer and registers */
705 p
->fb_orig_base
= fb_res
.start
;
706 p
->fb_orig_size
= fb_res
.end
- fb_res
.start
+ 1;
707 /* use the big-endian aperture (??) */
708 p
->frame_buffer_phys
= fb_res
.start
+ 0x800000;
709 p
->control_regs_phys
= reg_res
.start
;
710 p
->control_regs_size
= reg_res
.end
- reg_res
.start
+ 1;
712 if (!p
->fb_orig_base
||
713 !request_mem_region(p
->fb_orig_base
,p
->fb_orig_size
,"controlfb")) {
717 /* map at most 8MB for the frame buffer */
718 p
->frame_buffer
= __ioremap(p
->frame_buffer_phys
, 0x800000,
721 if (!p
->control_regs_phys
||
722 !request_mem_region(p
->control_regs_phys
, p
->control_regs_size
,
724 p
->control_regs_phys
= 0;
727 p
->control_regs
= ioremap(p
->control_regs_phys
, p
->control_regs_size
);
729 p
->cmap_regs_phys
= 0xf301b000; /* XXX not in prom? */
730 if (!request_mem_region(p
->cmap_regs_phys
, 0x1000, "controlfb cmap")) {
731 p
->cmap_regs_phys
= 0;
734 p
->cmap_regs
= ioremap(p
->cmap_regs_phys
, 0x1000);
736 if (!p
->cmap_regs
|| !p
->control_regs
|| !p
->frame_buffer
)
743 if (init_control(p
) < 0)
754 * Get the monitor sense value.
755 * Note that this can be called before calibrate_delay,
756 * so we can't use udelay.
758 static int read_control_sense(struct fb_info_control
*p
)
762 out_le32(CNTRL_REG(p
,mon_sense
), 7); /* drive all lines high */
764 out_le32(CNTRL_REG(p
,mon_sense
), 077); /* turn off drivers */
766 sense
= (in_le32(CNTRL_REG(p
,mon_sense
)) & 0x1c0) << 2;
768 /* drive each sense line low in turn and collect the other 2 */
769 out_le32(CNTRL_REG(p
,mon_sense
), 033); /* drive A low */
771 sense
|= (in_le32(CNTRL_REG(p
,mon_sense
)) & 0xc0) >> 2;
772 out_le32(CNTRL_REG(p
,mon_sense
), 055); /* drive B low */
774 sense
|= ((in_le32(CNTRL_REG(p
,mon_sense
)) & 0x100) >> 5)
775 | ((in_le32(CNTRL_REG(p
,mon_sense
)) & 0x40) >> 4);
776 out_le32(CNTRL_REG(p
,mon_sense
), 066); /* drive C low */
778 sense
|= (in_le32(CNTRL_REG(p
,mon_sense
)) & 0x180) >> 7;
780 out_le32(CNTRL_REG(p
,mon_sense
), 077); /* turn off drivers */
785 /********************** Various translation functions **********************/
787 #define CONTROL_PIXCLOCK_BASE 256016
788 #define CONTROL_PIXCLOCK_MIN 5000 /* ~ 200 MHz dot clock */
791 * calculate the clock paramaters to be sent to CUDA according to given
792 * pixclock in pico second.
794 static int calc_clock_params(unsigned long clk
, unsigned char *param
)
796 unsigned long p0
, p1
, p2
, k
, l
, m
, n
, min
;
798 if (clk
> (CONTROL_PIXCLOCK_BASE
<< 3))
801 p2
= ((clk
<< 4) < CONTROL_PIXCLOCK_BASE
)? 3: 2;
805 for (k
= 1, min
= l
; k
< 32; k
++) {
808 m
= CONTROL_PIXCLOCK_BASE
* k
;
811 if (n
&& (n
< 128) && rem
< min
) {
829 * This routine takes a user-supplied var, and picks the best vmode/cmode
833 static int control_var_to_par(struct fb_var_screeninfo
*var
,
834 struct fb_par_control
*par
, const struct fb_info
*fb_info
)
836 int cmode
, piped_diff
, hstep
;
837 unsigned hperiod
, hssync
, hsblank
, hesync
, heblank
, piped
, heq
, hlfln
,
838 hserr
, vperiod
, vssync
, vesync
, veblank
, vsblank
, vswin
, vewin
;
839 unsigned long pixclock
;
840 struct fb_info_control
*p
= (struct fb_info_control
*) fb_info
;
841 struct control_regvals
*r
= &par
->regvals
;
843 switch (var
->bits_per_pixel
) {
845 par
->cmode
= CMODE_8
;
846 if (p
->total_vram
> 0x200000) {
848 r
->radacal_ctrl
= 0x20;
852 r
->radacal_ctrl
= 0x10;
858 par
->cmode
= CMODE_16
;
859 if (p
->total_vram
> 0x200000) {
861 r
->radacal_ctrl
= 0x24;
865 r
->radacal_ctrl
= 0x14;
870 par
->cmode
= CMODE_32
;
871 if (p
->total_vram
> 0x200000) {
873 r
->radacal_ctrl
= 0x28;
876 r
->radacal_ctrl
= 0x18;
885 * adjust xres and vxres so that the corresponding memory widths are
888 hstep
= 31 >> par
->cmode
;
889 par
->xres
= (var
->xres
+ hstep
) & ~hstep
;
890 par
->vxres
= (var
->xres_virtual
+ hstep
) & ~hstep
;
891 par
->xoffset
= (var
->xoffset
+ hstep
) & ~hstep
;
892 if (par
->vxres
< par
->xres
)
893 par
->vxres
= par
->xres
;
894 par
->pitch
= par
->vxres
<< par
->cmode
;
896 par
->yres
= var
->yres
;
897 par
->vyres
= var
->yres_virtual
;
898 par
->yoffset
= var
->yoffset
;
899 if (par
->vyres
< par
->yres
)
900 par
->vyres
= par
->yres
;
902 par
->sync
= var
->sync
;
904 if (par
->pitch
* par
->vyres
+ CTRLFB_OFF
> p
->total_vram
)
907 if (par
->xoffset
+ par
->xres
> par
->vxres
)
908 par
->xoffset
= par
->vxres
- par
->xres
;
909 if (par
->yoffset
+ par
->yres
> par
->vyres
)
910 par
->yoffset
= par
->vyres
- par
->yres
;
912 pixclock
= (var
->pixclock
< CONTROL_PIXCLOCK_MIN
)? CONTROL_PIXCLOCK_MIN
:
914 if (calc_clock_params(pixclock
, r
->clock_params
))
917 hperiod
= ((var
->left_margin
+ par
->xres
+ var
->right_margin
918 + var
->hsync_len
) >> 1) - 2;
919 hssync
= hperiod
+ 1;
920 hsblank
= hssync
- (var
->right_margin
>> 1);
921 hesync
= (var
->hsync_len
>> 1) - 1;
922 heblank
= (var
->left_margin
>> 1) + hesync
;
923 piped
= heblank
- piped_diff
;
924 heq
= var
->hsync_len
>> 2;
925 hlfln
= (hperiod
+2) >> 1;
926 hserr
= hssync
-hesync
;
927 vperiod
= (var
->vsync_len
+ var
->lower_margin
+ par
->yres
928 + var
->upper_margin
) << 1;
929 vssync
= vperiod
- 2;
930 vesync
= (var
->vsync_len
<< 1) - vperiod
+ vssync
;
931 veblank
= (var
->upper_margin
<< 1) + vesync
;
932 vsblank
= vssync
- (var
->lower_margin
<< 1);
933 vswin
= (vsblank
+vssync
) >> 1;
934 vewin
= (vesync
+veblank
) >> 1;
937 r
->regs
[1] = vsblank
;
938 r
->regs
[2] = veblank
;
942 r
->regs
[6] = vperiod
;
944 r
->regs
[8] = hperiod
;
945 r
->regs
[9] = hsblank
;
946 r
->regs
[10] = heblank
;
947 r
->regs
[11] = hesync
;
948 r
->regs
[12] = hssync
;
953 if (par
->xres
>= 1280 && par
->cmode
>= CMODE_16
)
958 if (mac_var_to_vmode(var
, &par
->vmode
, &cmode
))
966 * Convert hardware data in par to an fb_var_screeninfo
969 static void control_par_to_var(struct fb_par_control
*par
, struct fb_var_screeninfo
*var
)
971 struct control_regints
*rv
;
973 rv
= (struct control_regints
*) par
->regvals
.regs
;
975 memset(var
, 0, sizeof(*var
));
976 var
->xres
= par
->xres
;
977 var
->yres
= par
->yres
;
978 var
->xres_virtual
= par
->vxres
;
979 var
->yres_virtual
= par
->vyres
;
980 var
->xoffset
= par
->xoffset
;
981 var
->yoffset
= par
->yoffset
;
986 var
->bits_per_pixel
= 8;
988 var
->green
.length
= 8;
989 var
->blue
.length
= 8;
991 case CMODE_16
: /* RGB 555 */
992 var
->bits_per_pixel
= 16;
993 var
->red
.offset
= 10;
995 var
->green
.offset
= 5;
996 var
->green
.length
= 5;
997 var
->blue
.length
= 5;
999 case CMODE_32
: /* RGB 888 */
1000 var
->bits_per_pixel
= 32;
1001 var
->red
.offset
= 16;
1002 var
->red
.length
= 8;
1003 var
->green
.offset
= 8;
1004 var
->green
.length
= 8;
1005 var
->blue
.length
= 8;
1006 var
->transp
.offset
= 24;
1007 var
->transp
.length
= 8;
1012 var
->vmode
= FB_VMODE_NONINTERLACED
;
1014 var
->left_margin
= (rv
->heblank
- rv
->hesync
) << 1;
1015 var
->right_margin
= (rv
->hssync
- rv
->hsblank
) << 1;
1016 var
->hsync_len
= (rv
->hperiod
+ 2 - rv
->hssync
+ rv
->hesync
) << 1;
1018 var
->upper_margin
= (rv
->veblank
- rv
->vesync
) >> 1;
1019 var
->lower_margin
= (rv
->vssync
- rv
->vsblank
) >> 1;
1020 var
->vsync_len
= (rv
->vperiod
- rv
->vssync
+ rv
->vesync
) >> 1;
1022 var
->sync
= par
->sync
;
1025 * 10^12 * clock_params[0] / (3906400 * clock_params[1]
1026 * * 2^clock_params[2])
1027 * (10^12 * clock_params[0] / (3906400 * clock_params[1]))
1028 * >> clock_params[2]
1030 /* (255990.17 * clock_params[0] / clock_params[1]) >> clock_params[2] */
1031 var
->pixclock
= CONTROL_PIXCLOCK_BASE
* par
->regvals
.clock_params
[0];
1032 var
->pixclock
/= par
->regvals
.clock_params
[1];
1033 var
->pixclock
>>= par
->regvals
.clock_params
[2];
1037 * Set misc info vars for this driver
1039 static void __init
control_init_info(struct fb_info
*info
, struct fb_info_control
*p
)
1042 info
->par
= &p
->par
;
1043 info
->fbops
= &controlfb_ops
;
1044 info
->pseudo_palette
= p
->pseudo_palette
;
1045 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_YPAN
;
1046 info
->screen_base
= p
->frame_buffer
+ CTRLFB_OFF
;
1048 fb_alloc_cmap(&info
->cmap
, 256, 0);
1050 /* Fill fix common fields */
1051 strcpy(info
->fix
.id
, "control");
1052 info
->fix
.mmio_start
= p
->control_regs_phys
;
1053 info
->fix
.mmio_len
= sizeof(struct control_regs
);
1054 info
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
1055 info
->fix
.smem_start
= p
->frame_buffer_phys
+ CTRLFB_OFF
;
1056 info
->fix
.smem_len
= p
->total_vram
- CTRLFB_OFF
;
1057 info
->fix
.ywrapstep
= 0;
1058 info
->fix
.type_aux
= 0;
1059 info
->fix
.accel
= FB_ACCEL_NONE
;
1063 static void control_cleanup(void)
1065 struct fb_info_control
*p
= control_fb
;
1071 iounmap(p
->cmap_regs
);
1072 if (p
->control_regs
)
1073 iounmap(p
->control_regs
);
1074 if (p
->frame_buffer
) {
1075 if (p
->control_use_bank2
)
1076 p
->frame_buffer
-= 0x600000;
1077 iounmap(p
->frame_buffer
);
1079 if (p
->cmap_regs_phys
)
1080 release_mem_region(p
->cmap_regs_phys
, 0x1000);
1081 if (p
->control_regs_phys
)
1082 release_mem_region(p
->control_regs_phys
, p
->control_regs_size
);
1083 if (p
->fb_orig_base
)
1084 release_mem_region(p
->fb_orig_base
, p
->fb_orig_size
);
This page took 0.053229 seconds and 6 git commands to generate.