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/tty.h>
40 #include <linux/slab.h>
41 #include <linux/vmalloc.h>
42 #include <linux/delay.h>
43 #include <linux/interrupt.h>
45 #include <linux/init.h>
46 #include <linux/pci.h>
47 #include <linux/nvram.h>
48 #include <linux/adb.h>
49 #include <linux/cuda.h>
52 #include <asm/pgtable.h>
53 #include <asm/btext.h>
56 #include "controlfb.h"
58 struct fb_par_control
{
64 struct control_regvals regvals
;
69 #define DIRTY(z) ((x)->z != (y)->z)
70 #define DIRTY_CMAP(z) (memcmp(&((x)->z), &((y)->z), sizeof((y)->z)))
71 static inline int PAR_EQUAL(struct fb_par_control
*x
, struct fb_par_control
*y
)
76 for (i
= 0; i
< 3; i
++)
77 results
&= !DIRTY(regvals
.clock_params
[i
]);
80 for (i
= 0; i
< 16; i
++)
81 results
&= !DIRTY(regvals
.regs
[i
]);
84 return (!DIRTY(cmode
) && !DIRTY(xres
) && !DIRTY(yres
)
85 && !DIRTY(vxres
) && !DIRTY(vyres
));
87 static inline int VAR_MATCH(struct fb_var_screeninfo
*x
, struct fb_var_screeninfo
*y
)
89 return (!DIRTY(bits_per_pixel
) && !DIRTY(xres
)
90 && !DIRTY(yres
) && !DIRTY(xres_virtual
)
91 && !DIRTY(yres_virtual
)
92 && !DIRTY_CMAP(red
) && !DIRTY_CMAP(green
) && !DIRTY_CMAP(blue
));
95 struct fb_info_control
{
97 struct fb_par_control par
;
98 u32 pseudo_palette
[17];
100 struct cmap_regs __iomem
*cmap_regs
;
101 unsigned long cmap_regs_phys
;
103 struct control_regs __iomem
*control_regs
;
104 unsigned long control_regs_phys
;
105 unsigned long control_regs_size
;
107 __u8 __iomem
*frame_buffer
;
108 unsigned long frame_buffer_phys
;
109 unsigned long fb_orig_base
;
110 unsigned long fb_orig_size
;
112 int control_use_bank2
;
113 unsigned long total_vram
;
114 unsigned char vram_attr
;
117 /* control register access macro */
118 #define CNTRL_REG(INFO,REG) (&(((INFO)->control_regs->REG).r))
121 /******************** Prototypes for exported functions ********************/
125 static int controlfb_pan_display(struct fb_var_screeninfo
*var
,
126 struct fb_info
*info
);
127 static int controlfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
128 u_int transp
, struct fb_info
*info
);
129 static int controlfb_blank(int blank_mode
, struct fb_info
*info
);
130 static int controlfb_mmap(struct fb_info
*info
,
131 struct vm_area_struct
*vma
);
132 static int controlfb_set_par (struct fb_info
*info
);
133 static int controlfb_check_var (struct fb_var_screeninfo
*var
, struct fb_info
*info
);
135 /******************** Prototypes for internal functions **********************/
137 static void set_control_clock(unsigned char *params
);
138 static int init_control(struct fb_info_control
*p
);
139 static void control_set_hardware(struct fb_info_control
*p
,
140 struct fb_par_control
*par
);
141 static int control_of_init(struct device_node
*dp
);
142 static void find_vram_size(struct fb_info_control
*p
);
143 static int read_control_sense(struct fb_info_control
*p
);
144 static int calc_clock_params(unsigned long clk
, unsigned char *param
);
145 static int control_var_to_par(struct fb_var_screeninfo
*var
,
146 struct fb_par_control
*par
, const struct fb_info
*fb_info
);
147 static inline void control_par_to_var(struct fb_par_control
*par
,
148 struct fb_var_screeninfo
*var
);
149 static void control_init_info(struct fb_info
*info
, struct fb_info_control
*p
);
150 static void control_cleanup(void);
153 /************************** Internal variables *******************************/
155 static struct fb_info_control
*control_fb
;
157 static int default_vmode __initdata
= VMODE_NVRAM
;
158 static int default_cmode __initdata
= CMODE_NVRAM
;
161 static struct fb_ops controlfb_ops
= {
162 .owner
= THIS_MODULE
,
163 .fb_check_var
= controlfb_check_var
,
164 .fb_set_par
= controlfb_set_par
,
165 .fb_setcolreg
= controlfb_setcolreg
,
166 .fb_pan_display
= controlfb_pan_display
,
167 .fb_blank
= controlfb_blank
,
168 .fb_mmap
= controlfb_mmap
,
169 .fb_fillrect
= cfb_fillrect
,
170 .fb_copyarea
= cfb_copyarea
,
171 .fb_imageblit
= cfb_imageblit
,
175 /******************** The functions for controlfb_ops ********************/
178 MODULE_LICENSE("GPL");
180 int init_module(void)
182 struct device_node
*dp
;
184 dp
= find_devices("control");
185 if (dp
!= 0 && !control_of_init(dp
))
191 void cleanup_module(void)
198 * Checks a var structure
200 static int controlfb_check_var (struct fb_var_screeninfo
*var
, struct fb_info
*info
)
202 struct fb_par_control par
;
205 err
= control_var_to_par(var
, &par
, info
);
208 control_par_to_var(&par
, var
);
214 * Applies current var to display
216 static int controlfb_set_par (struct fb_info
*info
)
218 struct fb_info_control
*p
= (struct fb_info_control
*) info
;
219 struct fb_par_control par
;
222 if((err
= control_var_to_par(&info
->var
, &par
, info
))) {
223 printk (KERN_ERR
"controlfb_set_par: error calling"
224 " control_var_to_par: %d.\n", err
);
228 control_set_hardware(p
, &par
);
230 info
->fix
.visual
= (p
->par
.cmode
== CMODE_8
) ?
231 FB_VISUAL_PSEUDOCOLOR
: FB_VISUAL_DIRECTCOLOR
;
232 info
->fix
.line_length
= p
->par
.pitch
;
233 info
->fix
.xpanstep
= 32 >> p
->par
.cmode
;
234 info
->fix
.ypanstep
= 1;
240 * Set screen start address according to var offset values
242 static inline void set_screen_start(int xoffset
, int yoffset
,
243 struct fb_info_control
*p
)
245 struct fb_par_control
*par
= &p
->par
;
247 par
->xoffset
= xoffset
;
248 par
->yoffset
= yoffset
;
249 out_le32(CNTRL_REG(p
,start_addr
),
250 par
->yoffset
* par
->pitch
+ (par
->xoffset
<< par
->cmode
));
254 static int controlfb_pan_display(struct fb_var_screeninfo
*var
,
255 struct fb_info
*info
)
257 unsigned int xoffset
, hstep
;
258 struct fb_info_control
*p
= (struct fb_info_control
*)info
;
259 struct fb_par_control
*par
= &p
->par
;
262 * make sure start addr will be 32-byte aligned
264 hstep
= 0x1f >> par
->cmode
;
265 xoffset
= (var
->xoffset
+ hstep
) & ~hstep
;
267 if (xoffset
+par
->xres
> par
->vxres
||
268 var
->yoffset
+par
->yres
> par
->vyres
)
271 set_screen_start(xoffset
, var
->yoffset
, p
);
278 * Private mmap since we want to have a different caching on the framebuffer
280 * Note there's no locking in here; it's done in fb_mmap() in fbmem.c.
282 static int controlfb_mmap(struct fb_info
*info
,
283 struct vm_area_struct
*vma
)
285 unsigned long off
, start
;
288 off
= vma
->vm_pgoff
<< PAGE_SHIFT
;
290 /* frame buffer memory */
291 start
= info
->fix
.smem_start
;
292 len
= PAGE_ALIGN((start
& ~PAGE_MASK
)+info
->fix
.smem_len
);
294 /* memory mapped io */
296 if (info
->var
.accel_flags
)
298 start
= info
->fix
.mmio_start
;
299 len
= PAGE_ALIGN((start
& ~PAGE_MASK
)+info
->fix
.mmio_len
);
300 pgprot_val(vma
->vm_page_prot
) |= _PAGE_NO_CACHE
|_PAGE_GUARDED
;
303 pgprot_val(vma
->vm_page_prot
) |= _PAGE_WRITETHRU
;
306 if ((vma
->vm_end
- vma
->vm_start
+ off
) > len
)
309 vma
->vm_pgoff
= off
>> PAGE_SHIFT
;
310 if (io_remap_pfn_range(vma
, vma
->vm_start
, off
>> PAGE_SHIFT
,
311 vma
->vm_end
- vma
->vm_start
, vma
->vm_page_prot
))
317 static int controlfb_blank(int blank_mode
, struct fb_info
*info
)
319 struct fb_info_control
*p
= (struct fb_info_control
*) info
;
322 ctrl
= ld_le32(CNTRL_REG(p
,ctrl
));
324 switch (blank_mode
) {
325 case FB_BLANK_VSYNC_SUSPEND
:
328 case FB_BLANK_HSYNC_SUSPEND
:
331 case FB_BLANK_POWERDOWN
:
334 case FB_BLANK_NORMAL
:
344 out_le32(CNTRL_REG(p
,ctrl
), ctrl
);
349 static int controlfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
350 u_int transp
, struct fb_info
*info
)
352 struct fb_info_control
*p
= (struct fb_info_control
*) info
;
362 out_8(&p
->cmap_regs
->addr
, regno
); /* tell clut what addr to fill */
363 out_8(&p
->cmap_regs
->lut
, r
); /* send one color channel at */
364 out_8(&p
->cmap_regs
->lut
, g
); /* a time... */
365 out_8(&p
->cmap_regs
->lut
, b
);
369 switch (p
->par
.cmode
) {
371 p
->pseudo_palette
[regno
] =
372 (regno
<< 10) | (regno
<< 5) | regno
;
375 i
= (regno
<< 8) | regno
;
376 p
->pseudo_palette
[regno
] = (i
<< 16) | i
;
385 /******************** End of controlfb_ops implementation ******************/
389 static void set_control_clock(unsigned char *params
)
391 #ifdef CONFIG_ADB_CUDA
392 struct adb_request req
;
395 for (i
= 0; i
< 3; ++i
) {
396 cuda_request(&req
, NULL
, 5, CUDA_PACKET
, CUDA_GET_SET_IIC
,
397 0x50, i
+ 1, params
[i
]);
398 while (!req
.complete
)
406 * finish off the driver initialization and register
408 static int __init
init_control(struct fb_info_control
*p
)
410 int full
, sense
, vmode
, cmode
, vyres
;
411 struct fb_var_screeninfo var
;
414 printk(KERN_INFO
"controlfb: ");
416 full
= p
->total_vram
== 0x400000;
418 /* 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
)
426 if (default_vmode
== VMODE_NVRAM
) {
427 vmode
= nvram_read_byte(NV_VMODE
);
428 if (vmode
< 1 || vmode
> VMODE_MAX
||
429 control_mac_modes
[vmode
- 1].m
[full
] < cmode
) {
430 sense
= read_control_sense(p
);
431 printk("Monitor sense value = 0x%x, ", sense
);
432 vmode
= mac_map_monitor_sense(sense
);
433 if (control_mac_modes
[vmode
- 1].m
[full
] < cmode
)
434 vmode
= VMODE_640_480_60
;
438 if (control_mac_modes
[vmode
- 1].m
[full
] < cmode
) {
442 vmode
= VMODE_640_480_60
;
446 /* Initialize info structure */
447 control_init_info(&p
->info
, p
);
449 /* Setup default var */
450 if (mac_vmode_to_var(vmode
, cmode
, &var
) < 0) {
451 /* This shouldn't happen! */
452 printk("mac_vmode_to_var(%d, %d,) failed\n", vmode
, cmode
);
454 vmode
= VMODE_640_480_60
;
456 if (mac_vmode_to_var(vmode
, cmode
, &var
) < 0) {
457 printk(KERN_ERR
"controlfb: mac_vmode_to_var() failed\n");
460 printk(KERN_INFO
"controlfb: ");
462 printk("using video mode %d and color mode %d.\n", vmode
, cmode
);
464 vyres
= (p
->total_vram
- CTRLFB_OFF
) / (var
.xres
<< cmode
);
465 if (vyres
> var
.yres
)
466 var
.yres_virtual
= vyres
;
468 /* Apply default var */
469 var
.activate
= FB_ACTIVATE_NOW
;
470 rc
= fb_set_var(&p
->info
, &var
);
471 if (rc
&& (vmode
!= VMODE_640_480_60
|| cmode
!= CMODE_8
))
474 /* Register with fbdev layer */
475 if (register_framebuffer(&p
->info
) < 0)
478 printk(KERN_INFO
"fb%d: control display adapter\n", p
->info
.node
);
483 #define RADACAL_WRITE(a,d) \
484 out_8(&p->cmap_regs->addr, (a)); \
485 out_8(&p->cmap_regs->dat, (d))
487 /* Now how about actually saying, Make it so! */
488 /* Some things in here probably don't need to be done each time. */
489 static void control_set_hardware(struct fb_info_control
*p
, struct fb_par_control
*par
)
491 struct control_regvals
*r
;
492 volatile struct preg __iomem
*rp
;
495 if (PAR_EQUAL(&p
->par
, par
)) {
497 * check if only xoffset or yoffset differs.
498 * this prevents flickers in typical VT switch case.
500 if (p
->par
.xoffset
!= par
->xoffset
||
501 p
->par
.yoffset
!= par
->yoffset
)
502 set_screen_start(par
->xoffset
, par
->yoffset
, p
);
508 cmode
= p
->par
.cmode
;
511 /* Turn off display */
512 out_le32(CNTRL_REG(p
,ctrl
), 0x400 | par
->ctrl
);
514 set_control_clock(r
->clock_params
);
516 RADACAL_WRITE(0x20, r
->radacal_ctrl
);
517 RADACAL_WRITE(0x21, p
->control_use_bank2
? 0 : 1);
518 RADACAL_WRITE(0x10, 0);
519 RADACAL_WRITE(0x11, 0);
521 rp
= &p
->control_regs
->vswin
;
522 for (i
= 0; i
< 16; ++i
, ++rp
)
523 out_le32(&rp
->r
, r
->regs
[i
]);
525 out_le32(CNTRL_REG(p
,pitch
), par
->pitch
);
526 out_le32(CNTRL_REG(p
,mode
), r
->mode
);
527 out_le32(CNTRL_REG(p
,vram_attr
), p
->vram_attr
);
528 out_le32(CNTRL_REG(p
,start_addr
), par
->yoffset
* par
->pitch
529 + (par
->xoffset
<< cmode
));
530 out_le32(CNTRL_REG(p
,rfrcnt
), 0x1e5);
531 out_le32(CNTRL_REG(p
,intr_ena
), 0);
533 /* Turn on display */
534 out_le32(CNTRL_REG(p
,ctrl
), par
->ctrl
);
536 #ifdef CONFIG_BOOTX_TEXT
537 btext_update_display(p
->frame_buffer_phys
+ CTRLFB_OFF
,
538 p
->par
.xres
, p
->par
.yres
,
539 (cmode
== CMODE_32
? 32: cmode
== CMODE_16
? 16: 8),
541 #endif /* CONFIG_BOOTX_TEXT */
546 * Parse user speficied options (`video=controlfb:')
548 static void __init
control_setup(char *options
)
552 if (!options
|| !*options
)
555 while ((this_opt
= strsep(&options
, ",")) != NULL
) {
556 if (!strncmp(this_opt
, "vmode:", 6)) {
557 int vmode
= simple_strtoul(this_opt
+6, NULL
, 0);
558 if (vmode
> 0 && vmode
<= VMODE_MAX
&&
559 control_mac_modes
[vmode
- 1].m
[1] >= 0)
560 default_vmode
= vmode
;
561 } else if (!strncmp(this_opt
, "cmode:", 6)) {
562 int depth
= simple_strtoul(this_opt
+6, NULL
, 0);
567 default_cmode
= depth
;
570 default_cmode
= CMODE_8
;
574 default_cmode
= CMODE_16
;
578 default_cmode
= CMODE_32
;
585 static int __init
control_init(void)
587 struct device_node
*dp
;
590 if (fb_get_options("controlfb", &option
))
592 control_setup(option
);
594 dp
= find_devices("control");
595 if (dp
!= 0 && !control_of_init(dp
))
601 module_init(control_init
);
603 /* Work out which banks of VRAM we have installed. */
604 /* danj: I guess the card just ignores writes to nonexistant VRAM... */
606 static void __init
find_vram_size(struct fb_info_control
*p
)
611 * Set VRAM in 2MB (bank 1) mode
612 * VRAM Bank 2 will be accessible through offset 0x600000 if present
613 * and VRAM Bank 1 will not respond at that offset even if present
615 out_le32(CNTRL_REG(p
,vram_attr
), 0x31);
617 out_8(&p
->frame_buffer
[0x600000], 0xb3);
618 out_8(&p
->frame_buffer
[0x600001], 0x71);
619 asm volatile("eieio; dcbf 0,%0" : : "r" (&p
->frame_buffer
[0x600000])
622 asm volatile("eieio; dcbi 0,%0" : : "r" (&p
->frame_buffer
[0x600000])
626 bank2
= (in_8(&p
->frame_buffer
[0x600000]) == 0xb3)
627 && (in_8(&p
->frame_buffer
[0x600001]) == 0x71);
630 * Set VRAM in 2MB (bank 2) mode
631 * VRAM Bank 1 will be accessible through offset 0x000000 if present
632 * and VRAM Bank 2 will not respond at that offset even if present
634 out_le32(CNTRL_REG(p
,vram_attr
), 0x39);
636 out_8(&p
->frame_buffer
[0], 0x5a);
637 out_8(&p
->frame_buffer
[1], 0xc7);
638 asm volatile("eieio; dcbf 0,%0" : : "r" (&p
->frame_buffer
[0])
641 asm volatile("eieio; dcbi 0,%0" : : "r" (&p
->frame_buffer
[0])
645 bank1
= (in_8(&p
->frame_buffer
[0]) == 0x5a)
646 && (in_8(&p
->frame_buffer
[1]) == 0xc7);
653 p
->control_use_bank2
= 1;
655 p
->frame_buffer
+= 0x600000;
656 p
->frame_buffer_phys
+= 0x600000;
670 p
->total_vram
= (bank1
+ bank2
) * 0x200000;
672 printk(KERN_INFO
"controlfb: VRAM Total = %dMB "
673 "(%dMB @ bank 1, %dMB @ bank 2)\n",
674 (bank1
+ bank2
) << 1, bank1
<< 1, bank2
<< 1);
679 * find "control" and initialize
681 static int __init
control_of_init(struct device_node
*dp
)
683 struct fb_info_control
*p
;
684 struct resource fb_res
, reg_res
;
687 printk(KERN_ERR
"controlfb: only one control is supported\n");
691 if (of_pci_address_to_resource(dp
, 2, &fb_res
) ||
692 of_pci_address_to_resource(dp
, 1, ®_res
)) {
693 printk(KERN_ERR
"can't get 2 addresses for control\n");
696 p
= kmalloc(sizeof(*p
), GFP_KERNEL
);
699 control_fb
= p
; /* save it for cleanups */
700 memset(p
, 0, sizeof(*p
));
702 /* Map in frame buffer and registers */
703 p
->fb_orig_base
= fb_res
.start
;
704 p
->fb_orig_size
= fb_res
.end
- fb_res
.start
+ 1;
705 /* use the big-endian aperture (??) */
706 p
->frame_buffer_phys
= fb_res
.start
+ 0x800000;
707 p
->control_regs_phys
= reg_res
.start
;
708 p
->control_regs_size
= reg_res
.end
- reg_res
.start
+ 1;
710 if (!p
->fb_orig_base
||
711 !request_mem_region(p
->fb_orig_base
,p
->fb_orig_size
,"controlfb")) {
715 /* map at most 8MB for the frame buffer */
716 p
->frame_buffer
= __ioremap(p
->frame_buffer_phys
, 0x800000,
719 if (!p
->control_regs_phys
||
720 !request_mem_region(p
->control_regs_phys
, p
->control_regs_size
,
722 p
->control_regs_phys
= 0;
725 p
->control_regs
= ioremap(p
->control_regs_phys
, p
->control_regs_size
);
727 p
->cmap_regs_phys
= 0xf301b000; /* XXX not in prom? */
728 if (!request_mem_region(p
->cmap_regs_phys
, 0x1000, "controlfb cmap")) {
729 p
->cmap_regs_phys
= 0;
732 p
->cmap_regs
= ioremap(p
->cmap_regs_phys
, 0x1000);
734 if (!p
->cmap_regs
|| !p
->control_regs
|| !p
->frame_buffer
)
741 if (init_control(p
) < 0)
752 * Get the monitor sense value.
753 * Note that this can be called before calibrate_delay,
754 * so we can't use udelay.
756 static int read_control_sense(struct fb_info_control
*p
)
760 out_le32(CNTRL_REG(p
,mon_sense
), 7); /* drive all lines high */
762 out_le32(CNTRL_REG(p
,mon_sense
), 077); /* turn off drivers */
764 sense
= (in_le32(CNTRL_REG(p
,mon_sense
)) & 0x1c0) << 2;
766 /* drive each sense line low in turn and collect the other 2 */
767 out_le32(CNTRL_REG(p
,mon_sense
), 033); /* drive A low */
769 sense
|= (in_le32(CNTRL_REG(p
,mon_sense
)) & 0xc0) >> 2;
770 out_le32(CNTRL_REG(p
,mon_sense
), 055); /* drive B low */
772 sense
|= ((in_le32(CNTRL_REG(p
,mon_sense
)) & 0x100) >> 5)
773 | ((in_le32(CNTRL_REG(p
,mon_sense
)) & 0x40) >> 4);
774 out_le32(CNTRL_REG(p
,mon_sense
), 066); /* drive C low */
776 sense
|= (in_le32(CNTRL_REG(p
,mon_sense
)) & 0x180) >> 7;
778 out_le32(CNTRL_REG(p
,mon_sense
), 077); /* turn off drivers */
783 /********************** Various translation functions **********************/
785 #define CONTROL_PIXCLOCK_BASE 256016
786 #define CONTROL_PIXCLOCK_MIN 5000 /* ~ 200 MHz dot clock */
789 * calculate the clock paramaters to be sent to CUDA according to given
790 * pixclock in pico second.
792 static int calc_clock_params(unsigned long clk
, unsigned char *param
)
794 unsigned long p0
, p1
, p2
, k
, l
, m
, n
, min
;
796 if (clk
> (CONTROL_PIXCLOCK_BASE
<< 3))
799 p2
= ((clk
<< 4) < CONTROL_PIXCLOCK_BASE
)? 3: 2;
803 for (k
= 1, min
= l
; k
< 32; k
++) {
806 m
= CONTROL_PIXCLOCK_BASE
* k
;
809 if (n
&& (n
< 128) && rem
< min
) {
827 * This routine takes a user-supplied var, and picks the best vmode/cmode
831 static int control_var_to_par(struct fb_var_screeninfo
*var
,
832 struct fb_par_control
*par
, const struct fb_info
*fb_info
)
834 int cmode
, piped_diff
, hstep
;
835 unsigned hperiod
, hssync
, hsblank
, hesync
, heblank
, piped
, heq
, hlfln
,
836 hserr
, vperiod
, vssync
, vesync
, veblank
, vsblank
, vswin
, vewin
;
837 unsigned long pixclock
;
838 struct fb_info_control
*p
= (struct fb_info_control
*) fb_info
;
839 struct control_regvals
*r
= &par
->regvals
;
841 switch (var
->bits_per_pixel
) {
843 par
->cmode
= CMODE_8
;
844 if (p
->total_vram
> 0x200000) {
846 r
->radacal_ctrl
= 0x20;
850 r
->radacal_ctrl
= 0x10;
856 par
->cmode
= CMODE_16
;
857 if (p
->total_vram
> 0x200000) {
859 r
->radacal_ctrl
= 0x24;
863 r
->radacal_ctrl
= 0x14;
868 par
->cmode
= CMODE_32
;
869 if (p
->total_vram
> 0x200000) {
871 r
->radacal_ctrl
= 0x28;
874 r
->radacal_ctrl
= 0x18;
883 * adjust xres and vxres so that the corresponding memory widths are
886 hstep
= 31 >> par
->cmode
;
887 par
->xres
= (var
->xres
+ hstep
) & ~hstep
;
888 par
->vxres
= (var
->xres_virtual
+ hstep
) & ~hstep
;
889 par
->xoffset
= (var
->xoffset
+ hstep
) & ~hstep
;
890 if (par
->vxres
< par
->xres
)
891 par
->vxres
= par
->xres
;
892 par
->pitch
= par
->vxres
<< par
->cmode
;
894 par
->yres
= var
->yres
;
895 par
->vyres
= var
->yres_virtual
;
896 par
->yoffset
= var
->yoffset
;
897 if (par
->vyres
< par
->yres
)
898 par
->vyres
= par
->yres
;
900 par
->sync
= var
->sync
;
902 if (par
->pitch
* par
->vyres
+ CTRLFB_OFF
> p
->total_vram
)
905 if (par
->xoffset
+ par
->xres
> par
->vxres
)
906 par
->xoffset
= par
->vxres
- par
->xres
;
907 if (par
->yoffset
+ par
->yres
> par
->vyres
)
908 par
->yoffset
= par
->vyres
- par
->yres
;
910 pixclock
= (var
->pixclock
< CONTROL_PIXCLOCK_MIN
)? CONTROL_PIXCLOCK_MIN
:
912 if (calc_clock_params(pixclock
, r
->clock_params
))
915 hperiod
= ((var
->left_margin
+ par
->xres
+ var
->right_margin
916 + var
->hsync_len
) >> 1) - 2;
917 hssync
= hperiod
+ 1;
918 hsblank
= hssync
- (var
->right_margin
>> 1);
919 hesync
= (var
->hsync_len
>> 1) - 1;
920 heblank
= (var
->left_margin
>> 1) + hesync
;
921 piped
= heblank
- piped_diff
;
922 heq
= var
->hsync_len
>> 2;
923 hlfln
= (hperiod
+2) >> 1;
924 hserr
= hssync
-hesync
;
925 vperiod
= (var
->vsync_len
+ var
->lower_margin
+ par
->yres
926 + var
->upper_margin
) << 1;
927 vssync
= vperiod
- 2;
928 vesync
= (var
->vsync_len
<< 1) - vperiod
+ vssync
;
929 veblank
= (var
->upper_margin
<< 1) + vesync
;
930 vsblank
= vssync
- (var
->lower_margin
<< 1);
931 vswin
= (vsblank
+vssync
) >> 1;
932 vewin
= (vesync
+veblank
) >> 1;
935 r
->regs
[1] = vsblank
;
936 r
->regs
[2] = veblank
;
940 r
->regs
[6] = vperiod
;
942 r
->regs
[8] = hperiod
;
943 r
->regs
[9] = hsblank
;
944 r
->regs
[10] = heblank
;
945 r
->regs
[11] = hesync
;
946 r
->regs
[12] = hssync
;
951 if (par
->xres
>= 1280 && par
->cmode
>= CMODE_16
)
956 if (mac_var_to_vmode(var
, &par
->vmode
, &cmode
))
964 * Convert hardware data in par to an fb_var_screeninfo
967 static void control_par_to_var(struct fb_par_control
*par
, struct fb_var_screeninfo
*var
)
969 struct control_regints
*rv
;
971 rv
= (struct control_regints
*) par
->regvals
.regs
;
973 memset(var
, 0, sizeof(*var
));
974 var
->xres
= par
->xres
;
975 var
->yres
= par
->yres
;
976 var
->xres_virtual
= par
->vxres
;
977 var
->yres_virtual
= par
->vyres
;
978 var
->xoffset
= par
->xoffset
;
979 var
->yoffset
= par
->yoffset
;
984 var
->bits_per_pixel
= 8;
986 var
->green
.length
= 8;
987 var
->blue
.length
= 8;
989 case CMODE_16
: /* RGB 555 */
990 var
->bits_per_pixel
= 16;
991 var
->red
.offset
= 10;
993 var
->green
.offset
= 5;
994 var
->green
.length
= 5;
995 var
->blue
.length
= 5;
997 case CMODE_32
: /* RGB 888 */
998 var
->bits_per_pixel
= 32;
999 var
->red
.offset
= 16;
1000 var
->red
.length
= 8;
1001 var
->green
.offset
= 8;
1002 var
->green
.length
= 8;
1003 var
->blue
.length
= 8;
1004 var
->transp
.offset
= 24;
1005 var
->transp
.length
= 8;
1010 var
->vmode
= FB_VMODE_NONINTERLACED
;
1012 var
->left_margin
= (rv
->heblank
- rv
->hesync
) << 1;
1013 var
->right_margin
= (rv
->hssync
- rv
->hsblank
) << 1;
1014 var
->hsync_len
= (rv
->hperiod
+ 2 - rv
->hssync
+ rv
->hesync
) << 1;
1016 var
->upper_margin
= (rv
->veblank
- rv
->vesync
) >> 1;
1017 var
->lower_margin
= (rv
->vssync
- rv
->vsblank
) >> 1;
1018 var
->vsync_len
= (rv
->vperiod
- rv
->vssync
+ rv
->vesync
) >> 1;
1020 var
->sync
= par
->sync
;
1023 * 10^12 * clock_params[0] / (3906400 * clock_params[1]
1024 * * 2^clock_params[2])
1025 * (10^12 * clock_params[0] / (3906400 * clock_params[1]))
1026 * >> clock_params[2]
1028 /* (255990.17 * clock_params[0] / clock_params[1]) >> clock_params[2] */
1029 var
->pixclock
= CONTROL_PIXCLOCK_BASE
* par
->regvals
.clock_params
[0];
1030 var
->pixclock
/= par
->regvals
.clock_params
[1];
1031 var
->pixclock
>>= par
->regvals
.clock_params
[2];
1035 * Set misc info vars for this driver
1037 static void __init
control_init_info(struct fb_info
*info
, struct fb_info_control
*p
)
1040 info
->par
= &p
->par
;
1041 info
->fbops
= &controlfb_ops
;
1042 info
->pseudo_palette
= p
->pseudo_palette
;
1043 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_YPAN
;
1044 info
->screen_base
= p
->frame_buffer
+ CTRLFB_OFF
;
1046 fb_alloc_cmap(&info
->cmap
, 256, 0);
1048 /* Fill fix common fields */
1049 strcpy(info
->fix
.id
, "control");
1050 info
->fix
.mmio_start
= p
->control_regs_phys
;
1051 info
->fix
.mmio_len
= sizeof(struct control_regs
);
1052 info
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
1053 info
->fix
.smem_start
= p
->frame_buffer_phys
+ CTRLFB_OFF
;
1054 info
->fix
.smem_len
= p
->total_vram
- CTRLFB_OFF
;
1055 info
->fix
.ywrapstep
= 0;
1056 info
->fix
.type_aux
= 0;
1057 info
->fix
.accel
= FB_ACCEL_NONE
;
1061 static void control_cleanup(void)
1063 struct fb_info_control
*p
= control_fb
;
1069 iounmap(p
->cmap_regs
);
1070 if (p
->control_regs
)
1071 iounmap(p
->control_regs
);
1072 if (p
->frame_buffer
) {
1073 if (p
->control_use_bank2
)
1074 p
->frame_buffer
-= 0x600000;
1075 iounmap(p
->frame_buffer
);
1077 if (p
->cmap_regs_phys
)
1078 release_mem_region(p
->cmap_regs_phys
, 0x1000);
1079 if (p
->control_regs_phys
)
1080 release_mem_region(p
->control_regs_phys
, p
->control_regs_size
);
1081 if (p
->fb_orig_base
)
1082 release_mem_region(p
->fb_orig_base
, p
->fb_orig_size
);