2 * linux/drivers/video/igafb.c -- Frame buffer device for IGA 1682
4 * Copyright (C) 1998 Vladimir Roganov and Gleb Raiko
6 * This driver is partly based on the Frame buffer device for ATI Mach64
7 * and partially on VESA-related code.
9 * Copyright (C) 1997-1998 Geert Uytterhoeven
10 * Copyright (C) 1998 Bernd Harries
11 * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
13 * This file is subject to the terms and conditions of the GNU General Public
14 * License. See the file COPYING in the main directory of this archive for
18 /******************************************************************************
21 Despite of IGA Card has advanced graphic acceleration,
22 initial version is almost dummy and does not support it.
23 Support for video modes and acceleration must be added
24 together with accelerated X-Windows driver implementation.
26 Most important thing at this moment is that we have working
27 JavaEngine1 console & X with new console interface.
29 ******************************************************************************/
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/string.h>
36 #include <linux/tty.h>
37 #include <linux/slab.h>
38 #include <linux/vmalloc.h>
39 #include <linux/delay.h>
40 #include <linux/interrupt.h>
42 #include <linux/init.h>
43 #include <linux/pci.h>
44 #include <linux/nvram.h>
53 #include <video/iga.h>
59 unsigned long prot_flag;
60 unsigned long prot_mask;
64 struct pci_mmap_map *mmap_map;
65 unsigned long frame_buffer_phys;
66 unsigned long io_base;
69 struct fb_info fb_info;
71 struct fb_fix_screeninfo igafb_fix __initdata = {
73 .type = FB_TYPE_PACKED_PIXELS,
77 struct fb_var_screeninfo default_var = {
78 /* 640x480, 60 Hz, Non-Interlaced (25.175 MHz dotclock) */
89 .accel_flags = FB_ACCEL_NONE,
97 .vmode = FB_VMODE_NONINTERLACED
101 struct fb_var_screeninfo default_var_1024x768 __initdata = {
102 /* 1024x768, 75 Hz, Non-Interlaced (78.75 MHz dotclock) */
105 .xres_virtual = 1024,
113 .accel_flags = FB_ACCEL_NONE,
121 .vmode = FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
124 struct fb_var_screeninfo default_var_1152x900 __initdata = {
125 /* 1152x900, 76 Hz, Non-Interlaced (110.0 MHz dotclock) */
128 .xres_virtual = 1152,
132 .green = { 0, 8, 0 },
136 .accel_flags = FB_ACCEL_NONE,
144 .vmode = FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
147 struct fb_var_screeninfo default_var_1280x1024 __initdata = {
148 /* 1280x1024, 75 Hz, Non-Interlaced (135.00 MHz dotclock) */
151 .xres_virtual = 1280,
152 .yres_virtual = 1024,
167 .vmode = FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
171 * Memory-mapped I/O functions for Sparc PCI
173 * On sparc we happen to access I/O with memory mapped functions too.
175 #define pci_inb(par, reg) readb(par->io_base+(reg))
176 #define pci_outb(par, val, reg) writeb(val, par->io_base+(reg))
178 static inline unsigned int iga_inb(struct iga_par *par, unsigned int reg,
181 pci_outb(par, idx, reg);
182 return pci_inb(par, reg + 1);
185 static inline void iga_outb(struct iga_par *par, unsigned char val,
186 unsigned int reg, unsigned int idx )
188 pci_outb(par, idx, reg);
189 pci_outb(par, val, reg+1);
192 #endif /* __sparc__ */
195 * Very important functionality for the JavaEngine1 computer:
196 * make screen border black (usign special IGA registers)
198 static void iga_blank_border(struct iga_par *par)
203 * PROM does this for us, so keep this code as a reminder
204 * about required read from 0x3DA and writing of 0x20 in the end.
206 (void) pci_inb(par, 0x3DA); /* required for every access */
207 pci_outb(par, IGA_IDX_VGA_OVERSCAN, IGA_ATTR_CTL);
208 (void) pci_inb(par, IGA_ATTR_CTL+1);
209 pci_outb(par, 0x38, IGA_ATTR_CTL);
210 pci_outb(par, 0x20, IGA_ATTR_CTL); /* re-enable visual */
213 * This does not work as it was designed because the overscan
214 * color is looked up in the palette. Therefore, under X11
215 * overscan changes color.
217 for (i=0; i < 3; i++)
218 iga_outb(par, 0, IGA_EXT_CNTRL, IGA_IDX_OVERSCAN_COLOR + i);
222 static int igafb_mmap(struct fb_info *info, struct file *file,
223 struct vm_area_struct *vma)
225 struct iga_par *par = (struct iga_par *)info->par;
226 unsigned int size, page, map_size = 0;
227 unsigned long map_offset = 0;
233 size = vma->vm_end - vma->vm_start;
235 /* To stop the swapper from even considering these pages. */
236 vma->vm_flags |= (VM_SHM | VM_LOCKED);
238 /* Each page, see which map applies */
239 for (page = 0; page < size; ) {
241 for (i = 0; par->mmap_map[i].size; i++) {
242 unsigned long start = par->mmap_map[i].voff;
243 unsigned long end = start + par->mmap_map[i].size;
244 unsigned long offset = (vma->vm_pgoff << PAGE_SHIFT) + page;
251 map_size = par->mmap_map[i].size - (offset - start);
252 map_offset = par->mmap_map[i].poff + (offset - start);
259 if (page + map_size > size)
260 map_size = size - page;
262 pgprot_val(vma->vm_page_prot) &= ~(par->mmap_map[i].prot_mask);
263 pgprot_val(vma->vm_page_prot) |= par->mmap_map[i].prot_flag;
265 if (remap_page_range(vma, vma->vm_start + page, map_offset,
266 map_size, vma->vm_page_prot))
275 vma->vm_flags |= VM_IO;
278 #endif /* __sparc__ */
280 static int igafb_setcolreg(unsigned regno, unsigned red, unsigned green,
281 unsigned blue, unsigned transp,
282 struct fb_info *info)
285 * Set a single color register. The values supplied are
286 * already rounded down to the hardware's capabilities
287 * (according to the entries in the `var' structure). Return
288 * != 0 for invalid regno.
290 struct iga_par *par = (struct iga_par *)info->par;
292 if (regno >= info->cmap.len)
295 pci_outb(par, regno, DAC_W_INDEX);
296 pci_outb(par, red, DAC_DATA);
297 pci_outb(par, green, DAC_DATA);
298 pci_outb(par, blue, DAC_DATA);
301 switch (info->var.bits_per_pixel) {
303 ((u16*)(info->pseudo_palette))[regno] =
304 (regno << 10) | (regno << 5) | regno;
307 ((u32*)(info->pseudo_palette))[regno] =
308 (regno << 16) | (regno << 8) | regno;
312 i = (regno << 8) | regno;
313 ((u32*)(info->pseudo_palette))[regno] = (i << 16) | i;
322 * Framebuffer option structure
324 static struct fb_ops igafb_ops = {
325 .owner = THIS_MODULE,
326 .fb_setcolreg = igafb_setcolreg,
327 .fb_fillrect = cfb_fillrect,
328 .fb_copyarea = cfb_copyarea,
329 .fb_imageblit = cfb_imageblit,
331 .fb_mmap = igafb_mmap,
335 static int __init iga_init(struct fb_info *info, struct iga_par *par)
337 char vramsz = iga_inb(par, IGA_EXT_CNTRL, IGA_IDX_EXT_BUS_CNTL)
343 info->fix.smem_len = 0x100000;
346 info->fix.smem_len = 0x200000;
349 case MEM_SIZE_RESERVED:
350 info->fix.smem_len = 0x400000;
354 if (info->var.bits_per_pixel > 8)
357 video_cmap_len = 256;
359 info->fbops = &igafb_ops;
360 info->flags = FBINFO_FLAG_DEFAULT;
362 fb_alloc_cmap(&info->cmap, video_cmap_len, 0);
364 if (register_framebuffer(info) < 0)
367 printk("fb%d: %s frame buffer device at 0x%08lx [%dMB VRAM]\n",
368 info->node, info->fix.id,
369 par->frame_buffer_phys, info->fix.smem_len >> 20);
371 iga_blank_border(par);
375 int __init igafb_init(void)
377 extern int con_is_present(void);
378 struct fb_info *info;
379 struct pci_dev *pdev;
382 int size, iga2000 = 0;
384 /* Do not attach when we have a serial console. */
385 if (!con_is_present())
388 pdev = pci_find_device(PCI_VENDOR_ID_INTERG,
389 PCI_DEVICE_ID_INTERG_1682, 0);
392 * XXX We tried to use cyber2000fb.c for IGS 2000.
393 * But it does not initialize the chip in JavaStation-E, alas.
395 pdev = pci_find_device(PCI_VENDOR_ID_INTERG, 0x2000, 0);
402 size = sizeof(struct fb_info) + sizeof(struct iga_par) + sizeof(u32)*16;
404 info = kmalloc(size, GFP_ATOMIC);
406 printk("igafb_init: can't alloc fb_info\n");
409 memset(info, 0, size);
411 par = (struct iga_par *) (info + 1);
414 if ((addr = pdev->resource[0].start) == 0) {
415 printk("igafb_init: no memory start\n");
420 if ((info->screen_base = ioremap(addr, 1024*1024*2)) == 0) {
421 printk("igafb_init: can't remap %lx[2M]\n", addr);
426 par->frame_buffer_phys = addr & PCI_BASE_ADDRESS_MEM_MASK;
430 * The following is sparc specific and this is why:
432 * IGS2000 has its I/O memory mapped and we want
433 * to generate memory cycles on PCI, e.g. do ioremap(),
434 * then readb/writeb() as in Documentation/IO-mapping.txt.
436 * IGS1682 is more traditional, it responds to PCI I/O
437 * cycles, so we want to access it with inb()/outb().
439 * On sparc, PCIC converts CPU memory access within
440 * phys window 0x3000xxxx into PCI I/O cycles. Therefore
441 * we may use readb/writeb to access them with IGS1682.
443 * We do not take io_base_phys from resource[n].start
444 * on IGS1682 because that chip is BROKEN. It does not
445 * have a base register for I/O. We just "know" what its
449 igafb_fix.mmio_start = par->frame_buffer_phys | 0x00800000;
451 igafb_fix.mmio_start = 0x30000000; /* XXX */
453 if ((par->io_base = (int) ioremap(igafb_fix.mmio_start, igafb_fix.smem_len)) == 0) {
454 printk("igafb_init: can't remap %lx[4K]\n", igafb_fix.mmio_start);
455 iounmap((void *)info->screen_base);
461 * Figure mmap addresses from PCI config space.
462 * We need two regions: for video memory and for I/O ports.
463 * Later one can add region for video coprocessor registers.
464 * However, mmap routine loops until size != 0, so we put
465 * one additional region with size == 0.
468 par->mmap_map = kmalloc(4 * sizeof(*par->mmap_map), GFP_ATOMIC);
469 if (!par->mmap_map) {
470 printk("igafb_init: can't alloc mmap_map\n");
471 iounmap((void *)par->io_base);
472 iounmap(info->screen_base);
477 memset(par->mmap_map, 0, 4 * sizeof(*par->mmap_map));
480 * Set default vmode and cmode from PROM properties.
483 struct pcidev_cookie *cookie = pdev->sysdata;
484 int node = cookie->prom_node;
485 int width = prom_getintdefault(node, "width", 1024);
486 int height = prom_getintdefault(node, "height", 768);
487 int depth = prom_getintdefault(node, "depth", 8);
491 default_var = default_var_1024x768;
495 default_var = default_var_1152x900;
499 default_var = default_var_1280x1024;
507 default_var.bits_per_pixel = 8;
510 default_var.bits_per_pixel = 16;
513 default_var.bits_per_pixel = 24;
516 default_var.bits_per_pixel = 32;
524 igafb_fix.smem_start = (unsigned long) info->screen_base;
525 igafb_fix.line_length = default_var.xres*(default_var.bits_per_pixel/8);
526 igafb_fix.visual = default_var.bits_per_pixel <= 8 ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
528 info->var = default_var;
529 info->fix = igafb_fix;
530 info->pseudo_palette = (void *)(par + 1);
532 if (!iga_init(info, par)) {
533 iounmap((void *)par->io_base);
534 iounmap(info->screen_base);
536 kfree(par->mmap_map);
542 * Add /dev/fb mmap values.
545 /* First region is for video memory */
546 par->mmap_map[0].voff = 0x0;
547 par->mmap_map[0].poff = par->frame_buffer_phys & PAGE_MASK;
548 par->mmap_map[0].size = info->fix.smem_len & PAGE_MASK;
549 par->mmap_map[0].prot_mask = SRMMU_CACHE;
550 par->mmap_map[0].prot_flag = SRMMU_WRITE;
552 /* Second region is for I/O ports */
553 par->mmap_map[1].voff = par->frame_buffer_phys & PAGE_MASK;
554 par->mmap_map[1].poff = info->fix.smem_start & PAGE_MASK;
555 par->mmap_map[1].size = PAGE_SIZE * 2; /* X wants 2 pages */
556 par->mmap_map[1].prot_mask = SRMMU_CACHE;
557 par->mmap_map[1].prot_flag = SRMMU_WRITE;
558 #endif /* __sparc__ */
563 int __init igafb_setup(char *options)
567 if (!options || !*options)
570 while ((this_opt = strsep(&options, ",")) != NULL) {
575 MODULE_LICENSE("GPL");