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/slab.h>
37 #include <linux/vmalloc.h>
38 #include <linux/delay.h>
39 #include <linux/interrupt.h>
41 #include <linux/init.h>
42 #include <linux/pci.h>
43 #include <linux/nvram.h>
52 #include <video/iga.h>
58 unsigned long prot_flag;
59 unsigned long prot_mask;
63 struct pci_mmap_map *mmap_map;
64 unsigned long frame_buffer_phys;
65 unsigned long io_base;
68 struct fb_info fb_info;
70 struct fb_fix_screeninfo igafb_fix __initdata = {
72 .type = FB_TYPE_PACKED_PIXELS,
76 struct fb_var_screeninfo default_var = {
77 /* 640x480, 60 Hz, Non-Interlaced (25.175 MHz dotclock) */
88 .accel_flags = FB_ACCEL_NONE,
96 .vmode = FB_VMODE_NONINTERLACED
100 struct fb_var_screeninfo default_var_1024x768 __initdata = {
101 /* 1024x768, 75 Hz, Non-Interlaced (78.75 MHz dotclock) */
104 .xres_virtual = 1024,
112 .accel_flags = FB_ACCEL_NONE,
120 .vmode = FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
123 struct fb_var_screeninfo default_var_1152x900 __initdata = {
124 /* 1152x900, 76 Hz, Non-Interlaced (110.0 MHz dotclock) */
127 .xres_virtual = 1152,
131 .green = { 0, 8, 0 },
135 .accel_flags = FB_ACCEL_NONE,
143 .vmode = FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
146 struct fb_var_screeninfo default_var_1280x1024 __initdata = {
147 /* 1280x1024, 75 Hz, Non-Interlaced (135.00 MHz dotclock) */
150 .xres_virtual = 1280,
151 .yres_virtual = 1024,
166 .vmode = FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
170 * Memory-mapped I/O functions for Sparc PCI
172 * On sparc we happen to access I/O with memory mapped functions too.
174 #define pci_inb(par, reg) readb(par->io_base+(reg))
175 #define pci_outb(par, val, reg) writeb(val, par->io_base+(reg))
177 static inline unsigned int iga_inb(struct iga_par *par, unsigned int reg,
180 pci_outb(par, idx, reg);
181 return pci_inb(par, reg + 1);
184 static inline void iga_outb(struct iga_par *par, unsigned char val,
185 unsigned int reg, unsigned int idx )
187 pci_outb(par, idx, reg);
188 pci_outb(par, val, reg+1);
191 #endif /* __sparc__ */
194 * Very important functionality for the JavaEngine1 computer:
195 * make screen border black (usign special IGA registers)
197 static void iga_blank_border(struct iga_par *par)
202 * PROM does this for us, so keep this code as a reminder
203 * about required read from 0x3DA and writing of 0x20 in the end.
205 (void) pci_inb(par, 0x3DA); /* required for every access */
206 pci_outb(par, IGA_IDX_VGA_OVERSCAN, IGA_ATTR_CTL);
207 (void) pci_inb(par, IGA_ATTR_CTL+1);
208 pci_outb(par, 0x38, IGA_ATTR_CTL);
209 pci_outb(par, 0x20, IGA_ATTR_CTL); /* re-enable visual */
212 * This does not work as it was designed because the overscan
213 * color is looked up in the palette. Therefore, under X11
214 * overscan changes color.
216 for (i=0; i < 3; i++)
217 iga_outb(par, 0, IGA_EXT_CNTRL, IGA_IDX_OVERSCAN_COLOR + i);
221 static int igafb_mmap(struct fb_info *info,
222 struct vm_area_struct *vma)
224 struct iga_par *par = (struct iga_par *)info->par;
225 unsigned int size, page, map_size = 0;
226 unsigned long map_offset = 0;
232 size = vma->vm_end - vma->vm_start;
234 /* Each page, see which map applies */
235 for (page = 0; page < size; ) {
237 for (i = 0; par->mmap_map[i].size; i++) {
238 unsigned long start = par->mmap_map[i].voff;
239 unsigned long end = start + par->mmap_map[i].size;
240 unsigned long offset = (vma->vm_pgoff << PAGE_SHIFT) + page;
247 map_size = par->mmap_map[i].size - (offset - start);
248 map_offset = par->mmap_map[i].poff + (offset - start);
255 if (page + map_size > size)
256 map_size = size - page;
258 pgprot_val(vma->vm_page_prot) &= ~(par->mmap_map[i].prot_mask);
259 pgprot_val(vma->vm_page_prot) |= par->mmap_map[i].prot_flag;
261 if (remap_pfn_range(vma, vma->vm_start + page,
262 map_offset >> PAGE_SHIFT, map_size, vma->vm_page_prot))
271 vma->vm_flags |= VM_IO;
274 #endif /* __sparc__ */
276 static int igafb_setcolreg(unsigned regno, unsigned red, unsigned green,
277 unsigned blue, unsigned transp,
278 struct fb_info *info)
281 * Set a single color register. The values supplied are
282 * already rounded down to the hardware's capabilities
283 * (according to the entries in the `var' structure). Return
284 * != 0 for invalid regno.
286 struct iga_par *par = (struct iga_par *)info->par;
288 if (regno >= info->cmap.len)
291 pci_outb(par, regno, DAC_W_INDEX);
292 pci_outb(par, red, DAC_DATA);
293 pci_outb(par, green, DAC_DATA);
294 pci_outb(par, blue, DAC_DATA);
297 switch (info->var.bits_per_pixel) {
299 ((u16*)(info->pseudo_palette))[regno] =
300 (regno << 10) | (regno << 5) | regno;
303 ((u32*)(info->pseudo_palette))[regno] =
304 (regno << 16) | (regno << 8) | regno;
308 i = (regno << 8) | regno;
309 ((u32*)(info->pseudo_palette))[regno] = (i << 16) | i;
318 * Framebuffer option structure
320 static struct fb_ops igafb_ops = {
321 .owner = THIS_MODULE,
322 .fb_setcolreg = igafb_setcolreg,
323 .fb_fillrect = cfb_fillrect,
324 .fb_copyarea = cfb_copyarea,
325 .fb_imageblit = cfb_imageblit,
327 .fb_mmap = igafb_mmap,
331 static int __init iga_init(struct fb_info *info, struct iga_par *par)
333 char vramsz = iga_inb(par, IGA_EXT_CNTRL, IGA_IDX_EXT_BUS_CNTL)
339 info->fix.smem_len = 0x100000;
342 info->fix.smem_len = 0x200000;
345 case MEM_SIZE_RESERVED:
346 info->fix.smem_len = 0x400000;
350 if (info->var.bits_per_pixel > 8)
353 video_cmap_len = 256;
355 info->fbops = &igafb_ops;
356 info->flags = FBINFO_DEFAULT;
358 fb_alloc_cmap(&info->cmap, video_cmap_len, 0);
360 if (register_framebuffer(info) < 0)
363 printk("fb%d: %s frame buffer device at 0x%08lx [%dMB VRAM]\n",
364 info->node, info->fix.id,
365 par->frame_buffer_phys, info->fix.smem_len >> 20);
367 iga_blank_border(par);
371 int __init igafb_init(void)
373 struct fb_info *info;
374 struct pci_dev *pdev;
377 int size, iga2000 = 0;
379 if (fb_get_options("igafb", NULL))
382 /* Do not attach when we have a serial console. */
383 if (!con_is_present())
386 pdev = pci_get_device(PCI_VENDOR_ID_INTERG,
387 PCI_DEVICE_ID_INTERG_1682, 0);
390 * XXX We tried to use cyber2000fb.c for IGS 2000.
391 * But it does not initialize the chip in JavaStation-E, alas.
393 pdev = pci_get_device(PCI_VENDOR_ID_INTERG, 0x2000, 0);
399 /* We leak a reference here but as it cannot be unloaded this is
400 fine. If you write unload code remember to free it in unload */
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);
531 info->device = &pdev->dev;
533 if (!iga_init(info, par)) {
534 iounmap((void *)par->io_base);
535 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_init(igafb_init);
576 MODULE_LICENSE("GPL");
577 static struct pci_device_id igafb_pci_tbl[] __devinitdata = {
578 { PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_1682,
579 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
583 MODULE_DEVICE_TABLE(pci, igafb_pci_tbl);