开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
neofb.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：58k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

neofb.c：源码内容
  1. /*
  2.  * linux/drivers/video/neofb.c -- NeoMagic Framebuffer Driver
  3.  *
  4.  * Copyright (c) 2001  Denis Oliver Kropp <dok@convergence.de>
  5.  *
  6.  *
  7.  * Card specific code is based on XFree86's neomagic driver.
  8.  * Framebuffer framework code is based on code of cyber2000fb.
  9.  *
  10.  * This file is subject to the terms and conditions of the GNU General
  11.  * Public License.  See the file COPYING in the main directory of this
  12.  * archive for more details.
  13.  *
  14.  *
  15.  * 0.3.2
  16.  *  - got rid of all floating point (dok)
  17.  *
  18.  * 0.3.1
  19.  *  - added module license (dok)
  20.  *
  21.  * 0.3
  22.  *  - hardware accelerated clear and move for 2200 and above (dok)
  23.  *  - maximum allowed dotclock is handled now (dok)
  24.  *
  25.  * 0.2.1
  26.  *  - correct panning after X usage (dok)
  27.  *  - added module and kernel parameters (dok)
  28.  *  - no stretching if external display is enabled (dok)
  29.  *
  30.  * 0.2
  31.  *  - initial version (dok)
  32.  *
  33.  *
  34.  * TODO
  35.  * - ioctl for internal/external switching
  36.  * - blanking
  37.  * - 32bit depth support, maybe impossible
  38.  * - disable pan-on-sync, need specs
  39.  *
  40.  * BUGS
  41.  * - white margin on bootup like with tdfxfb (colormap problem?)
  42.  *
  43.  */
  45. #include <linux/config.h>
  46. #include <linux/module.h>
  47. #include <linux/kernel.h>
  48. #include <linux/errno.h>
  49. #include <linux/string.h>
  50. #include <linux/mm.h>
  51. #include <linux/tty.h>
  52. #include <linux/slab.h>
  53. #include <linux/delay.h>
  54. #include <linux/fb.h>
  55. #include <linux/pci.h>
  56. #include <linux/init.h>
  58. #include <asm/io.h>
  59. #include <asm/irq.h>
  60. #include <asm/pgtable.h>
  61. #include <asm/system.h>
  62. #include <asm/uaccess.h>
  64. #ifdef CONFIG_MTRR
  65. #include <asm/mtrr.h>
  66. #endif
  68. #include <video/fbcon.h>
  69. #include <video/fbcon-cfb8.h>
  70. #include <video/fbcon-cfb16.h>
  71. #include <video/fbcon-cfb24.h>
  72. #include <video/fbcon-cfb32.h>
  74. #include "neofb.h"
  77. #define NEOFB_VERSION "0.3.2"
  79. /* --------------------------------------------------------------------- */
  81. static int disabled   = 0;
  82. static int internal   = 0;
  83. static int external   = 0;
  84. static int nostretch  = 0;
  85. static int nopciburst = 0;
  88. #ifdef MODULE
  90. MODULE_AUTHOR("(c) 2001-2002  Denis Oliver Kropp <dok@convergence.de>");
  91. MODULE_LICENSE("GPL");
  92. MODULE_DESCRIPTION("FBDev driver for NeoMagic PCI Chips");
  93. MODULE_PARM(disabled, "i");
  94. MODULE_PARM_DESC(disabled, "Disable this driver's initialization.");
  95. MODULE_PARM(internal, "i");
  96. MODULE_PARM_DESC(internal, "Enable output on internal LCD Display.");
  97. MODULE_PARM(external, "i");
  98. MODULE_PARM_DESC(external, "Enable output on external CRT.");
  99. MODULE_PARM(nostretch, "i");
  100. MODULE_PARM_DESC(nostretch, "Disable stretching of modes smaller than LCD.");
  101. MODULE_PARM(nopciburst, "i");
  102. MODULE_PARM_DESC(nopciburst, "Disable PCI burst mode.");
  104. #endif
  107. /* --------------------------------------------------------------------- */
  109. static biosMode bios8[] = {
  110.     { 320, 240, 0x40 },
  111.     { 300, 400, 0x42 },    
  112.     { 640, 400, 0x20 },
  113.     { 640, 480, 0x21 },
  114.     { 800, 600, 0x23 },
  115.     { 1024, 768, 0x25 },
  116. };
  118. static biosMode bios16[] = {
  119.     { 320, 200, 0x2e },
  120.     { 320, 240, 0x41 },
  121.     { 300, 400, 0x43 },
  122.     { 640, 480, 0x31 },
  123.     { 800, 600, 0x34 },
  124.     { 1024, 768, 0x37 },
  125. };
  127. static biosMode bios24[] = {
  128.     { 640, 480, 0x32 },
  129.     { 800, 600, 0x35 },
  130.     { 1024, 768, 0x38 }
  131. };
  133. #ifdef NO_32BIT_SUPPORT_YET
  134. /* FIXME: guessed values, wrong */
  135. static biosMode bios32[] = {
  136.     { 640, 480, 0x33 },
  137.     { 800, 600, 0x36 },
  138.     { 1024, 768, 0x39 }
  139.     };
  140. #endif
  142. static int neoFindMode (int xres, int yres, int depth)
  143. {
  144.   int xres_s;
  145.   int i, size;
  146.   biosMode *mode;
  148.   switch (depth)
  149.     {
  150.     case 8:
  151.       size = sizeof(bios8) / sizeof(biosMode);
  152.       mode = bios8;
  153.       break;
  154.     case 16:
  155.       size = sizeof(bios16) / sizeof(biosMode);
  156.       mode = bios16;
  157.       break;
  158.     case 24:
  159.       size = sizeof(bios24) / sizeof(biosMode);
  160.       mode = bios24;
  161.       break;
  162. #ifdef NO_32BIT_SUPPORT_YET
  163.     case 32:
  164.       size = sizeof(bios32) / sizeof(biosMode);
  165.       mode = bios32;
  166.       break;
  167. #endif
  168.     default:
  169.       return 0;
  170.     }
  172.   for (i = 0; i < size; i++)
  173.     {
  174.       if (xres <= mode[i].x_res)
  175. {
  176.   xres_s = mode[i].x_res;
  177.   for (; i < size; i++)
  178.     {
  179.       if (mode[i].x_res != xres_s)
  180. return mode[i-1].mode;
  181.       if (yres <= mode[i].y_res)
  182. return mode[i].mode;
  183.     }
  184. }
  185.     }
  186.   return mode[size - 1].mode;
  187. }
  189. /* -------------------- Hardware specific routines ------------------------- */
  191. /*
  192.  * Hardware Acceleration for Neo2200+
  193.  */
  194. static inline void neo2200_wait_idle (struct neofb_info *fb)
  195. {
  196.   int waitcycles;
  198.   while (fb->neo2200->bltStat & 1)
  199.     waitcycles++;
  200. }
  202. static inline void neo2200_wait_fifo (struct neofb_info *fb,
  203.                                       int requested_fifo_space)
  204. {
  205.   //  ndev->neo.waitfifo_calls++;
  206.   //  ndev->neo.waitfifo_sum += requested_fifo_space;
  208.   /* FIXME: does not work
  209.   if (neo_fifo_space < requested_fifo_space)
  210.     {
  211.       neo_fifo_waitcycles++;
  213.       while (1)
  214.     {
  215.       neo_fifo_space = (neo2200->bltStat >> 8);
  216.       if (neo_fifo_space >= requested_fifo_space)
  217.         break;
  218.     }
  219.     }
  220.   else
  221.     {
  222.       neo_fifo_cache_hits++;
  223.     }
  225.   neo_fifo_space -= requested_fifo_space;
  226.   */
  228.   neo2200_wait_idle (fb);
  229. }
  231. static inline void neo2200_accel_init (struct neofb_info        *fb,
  232.        struct fb_var_screeninfo *var)
  233. {
  234.   Neo2200 *neo2200 = fb->neo2200;
  235.   u32 bltMod, pitch;
  237.   neo2200_wait_idle (fb);
  239.   switch (var->bits_per_pixel)
  240.     {
  241.     case 8:
  242.       bltMod = NEO_MODE1_DEPTH8;
  243.       pitch  = var->xres_virtual;
  244.       break;
  245.     case 15:
  246.     case 16:
  247.       bltMod = NEO_MODE1_DEPTH16;
  248.       pitch  = var->xres_virtual * 2;
  249.       break;
  250.     default:
  251.       printk( KERN_ERR "neofb: neo2200_accel_init: unexpected bits per pixel!n" );
  252.       return;
  253.     }
  255.   neo2200->bltStat = bltMod << 16;
  256.   neo2200->pitch   = (pitch << 16) | pitch;
  257. }
  259. static void neo2200_accel_setup (struct display *p)
  260. {
  261.   struct neofb_info        *fb  = (struct neofb_info *)p->fb_info;
  262.   struct fb_var_screeninfo *var = &p->fb_info->var;
  264.   fb->dispsw->setup(p);
  266.   neo2200_accel_init (fb, var);
  267. }
  269. static void
  270. neo2200_accel_bmove (struct display *p, int sy, int sx, int dy, int dx,
  271.      int height, int width)
  272. {
  273.   struct neofb_info *fb = (struct neofb_info *)p->fb_info;
  274.   struct fb_var_screeninfo *var = &p->fb_info->var;
  275.   Neo2200 *neo2200 = fb->neo2200;
  276.   u_long src, dst;
  277.   int bpp, pitch, inc_y;
  278.   u_int fh, fw;
  280.   if (sx != dx)
  281.     {
  282.       neo2200_wait_idle (fb);
  283.       fb->dispsw->bmove(p, sy, sx, dy, dx, height, width);
  284.       return;
  285.     }
  287.   bpp    = (var->bits_per_pixel+7) / 8;
  288.   pitch  = var->xres_virtual * bpp;
  290.   fw     = fontwidth(p);
  291.   sx    *= fw * bpp;
  292.   dx    *= fw * bpp;
  293.   width *= fw;
  295.   fh     = fontheight(p);
  296.   sy    *= fh;
  297.   dy    *= fh;
  299.   if (sy > dy)
  300.     inc_y = fh;
  301.   else
  302.     {
  303.       inc_y  = -fh;
  304.       sy    += (height - 1) * fh;
  305.       dy    += (height - 1) * fh;
  306.     }
  308.   neo2200_wait_fifo (fb, 1);
  310.   /* set blt control */
  311.   neo2200->bltCntl = NEO_BC3_FIFO_EN      |
  312.                      NEO_BC3_SKIP_MAPPING |  0x0c0000;
  314.   while (height--)
  315.     {
  316.       src = sx + sy * pitch;
  317.       dst = dx + dy * pitch;
  319.       neo2200_wait_fifo (fb, 3);
  321.       neo2200->srcStart = src;
  322.       neo2200->dstStart = dst;
  323.       neo2200->xyExt = (fh << 16) | (width & 0xffff);
  325.       sy += inc_y;
  326.       dy += inc_y;
  327.     }
  328. }
  330. static void
  331. neo2200_accel_clear (struct vc_data *conp, struct display *p, int sy, int sx,
  332.      int height, int width)
  333. {
  334.   struct neofb_info *fb = (struct neofb_info *)p->fb_info;
  335.   struct fb_var_screeninfo *var = &p->fb_info->var;
  336.   Neo2200 *neo2200 = fb->neo2200;
  337.   u_long dst;
  338.   u_int fw, fh;
  339.   u32 bgx = attr_bgcol_ec(p, conp);
  341.   fw = fontwidth(p);
  342.   fh = fontheight(p);
  344.   dst    = sx * fw + sy * var->xres_virtual * fh;
  345.   width  = width * fw;
  346.   height = height * fh;
  348.   neo2200_wait_fifo (fb, 4);
  350.   /* set blt control */
  351.   neo2200->bltCntl  = NEO_BC3_FIFO_EN      |
  352.                       NEO_BC0_SRC_IS_FG    |
  353.                       NEO_BC3_SKIP_MAPPING |  0x0c0000;
  355.   switch (var->bits_per_pixel)
  356.     {
  357.     case 8:
  358.       neo2200->fgColor = bgx;
  359.       break;
  360.     case 16:
  361.       neo2200->fgColor = ((u16 *)(p->fb_info)->pseudo_palette)[bgx];
  362.       break;
  363.     }
  365.   neo2200->dstStart = dst * ((var->bits_per_pixel+7) / 8);
  367.   neo2200->xyExt    = (height << 16) | (width & 0xffff);
  368. }
  370. static void
  371. neo2200_accel_putc (struct vc_data *conp, struct display *p, int c,
  372.     int yy, int xx)
  373. {
  374.   struct neofb_info *fb = (struct neofb_info *)p->fb_info;
  376.   neo2200_wait_idle (fb);
  377.   fb->dispsw->putc(conp, p, c, yy, xx);
  378. }
  380. static void
  381. neo2200_accel_putcs (struct vc_data *conp, struct display *p,
  382.      const unsigned short *s, int count, int yy, int xx)
  383. {
  384.   struct neofb_info *fb = (struct neofb_info *)p->fb_info;
  386.   neo2200_wait_idle (fb);
  387.   fb->dispsw->putcs(conp, p, s, count, yy, xx);
  388. }
  390. static void neo2200_accel_revc (struct display *p, int xx, int yy)
  391. {
  392.   struct neofb_info *fb = (struct neofb_info *)p->fb_info;
  394.   neo2200_wait_idle (fb);
  395.   fb->dispsw->revc (p, xx, yy);
  396. }
  398. static void
  399. neo2200_accel_clear_margins (struct vc_data *conp, struct display *p,
  400.      int bottom_only)
  401. {
  402.   struct neofb_info *fb = (struct neofb_info *)p->fb_info;
  404.   fb->dispsw->clear_margins (conp, p, bottom_only);
  405. }
  407. static struct display_switch fbcon_neo2200_accel = {
  408.   setup: neo2200_accel_setup,
  409.   bmove: neo2200_accel_bmove,
  410.   clear: neo2200_accel_clear,
  411.   putc: neo2200_accel_putc,
  412.   putcs: neo2200_accel_putcs,
  413.   revc: neo2200_accel_revc,
  414.   clear_margins: neo2200_accel_clear_margins,
  415.   fontwidthmask: FONTWIDTH(8)|FONTWIDTH(16)
  416. };
  419. /* --------------------------------------------------------------------- */
  421. /*
  422.  *    Set a single color register. Return != 0 for invalid regno.
  423.  */
  424. static int neo_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  425.  u_int transp, struct fb_info *fb)
  426. {
  427.   struct neofb_info *info = (struct neofb_info *)fb;
  429.   if (regno >= NR_PALETTE)
  430.     return -EINVAL;
  432.   info->palette[regno].red    = red;
  433.   info->palette[regno].green  = green;
  434.   info->palette[regno].blue   = blue;
  435.   info->palette[regno].transp = transp;
  437.   switch (fb->var.bits_per_pixel)
  438.     {
  439. #ifdef FBCON_HAS_CFB8
  440.     case 8:
  441.       outb(regno, 0x3c8);
  443.       outb(red   >> 10, 0x3c9);
  444.       outb(green >> 10, 0x3c9);
  445.       outb(blue  >> 10, 0x3c9);
  446.       break;
  447. #endif
  449. #ifdef FBCON_HAS_CFB16
  450.     case 16:
  451.       if (regno < 16)
  452. ((u16 *)fb->pseudo_palette)[regno] = ((red   & 0xf800)      ) |
  453.                                      ((green & 0xfc00) >>  5) |
  454.                                              ((blue  & 0xf800) >> 11);
  455.       break;
  456. #endif
  458. #ifdef FBCON_HAS_CFB24
  459.     case 24:
  460.       if (regno < 16)
  461. ((u32 *)fb->pseudo_palette)[regno] = ((red   & 0xff00) << 8) |
  462.                                              ((green & 0xff00)     ) |
  463.                                      ((blue  & 0xff00) >> 8);
  464.       break;
  465. #endif
  467. #ifdef NO_32BIT_SUPPORT_YET
  468. #ifdef FBCON_HAS_CFB32
  469.     case 32:
  470.       if (regno < 16)
  471. ((u32 *)fb->pseudo_palette)[regno] = ((transp & 0xff00) << 16) |
  472.                                      ((red    & 0xff00) <<  8) |
  473.                                              ((green  & 0xff00)      ) |
  474.                                      ((blue   & 0xff00) >>  8);
  475.       break;
  476. #endif
  477. #endif
  479.     default:
  480.       return 1;
  481.     }
  483.   return 0;
  484. }
  486. static void vgaHWLock (void)
  487. {
  488.   /* Protect CRTC[0-7] */
  489.   VGAwCR (0x11, VGArCR (0x11) | 0x80);
  490. }
  492. static void vgaHWUnlock (void)
  493. {
  494.   /* Unprotect CRTC[0-7] */
  495.   VGAwCR (0x11, VGArCR (0x11) & ~0x80);
  496. }
  498. static void neoLock (void)
  499. {
  500.   VGAwGR (0x09, 0x00);
  501.   vgaHWLock();
  502. }
  504. static void neoUnlock (void)
  505. {
  506.   vgaHWUnlock();
  507.   VGAwGR (0x09, 0x26);
  508. }
  510. /*
  511.  * vgaHWSeqReset
  512.  *      perform a sequencer reset.
  513.  */
  514. void
  515. vgaHWSeqReset(int start)
  516. {
  517.   if (start)
  518.     VGAwSEQ (0x00, 0x01); /* Synchronous Reset */
  519.   else
  520.     VGAwSEQ (0x00, 0x03); /* End Reset */
  521. }
  523. void
  524. vgaHWProtect(int on)
  525. {
  526.   unsigned char tmp;
  527.   
  528.   if (on)
  529.     {
  530.       /*
  531.        * Turn off screen and disable sequencer.
  532.        */
  533.       tmp = VGArSEQ (0x01);
  535.       vgaHWSeqReset (1); /* start synchronous reset */
  536.       VGAwSEQ (0x01, tmp | 0x20); /* disable the display */
  538.       VGAenablePalette();
  539.     }
  540.   else
  541.     {
  542.       /*
  543.        * Reenable sequencer, then turn on screen.
  544.        */
  545.   
  546.       tmp = VGArSEQ (0x01);
  548.       VGAwSEQ (0x01, tmp & ~0x20); /* reenable display */
  549.       vgaHWSeqReset (0); /* clear synchronousreset */
  551.       VGAdisablePalette();
  552.     }
  553. }
  555. static void vgaHWRestore (const struct neofb_info *info,
  556.   const struct neofb_par  *par)
  557. {
  558.   int i;
  560.   VGAwMISC (par->MiscOutReg);
  562.   for (i = 1; i < 5; i++)
  563.     VGAwSEQ (i, par->Sequencer[i]);
  564.   
  565.   /* Ensure CRTC registers 0-7 are unlocked by clearing bit 7 or CRTC[17] */
  566.   VGAwCR (17, par->CRTC[17] & ~0x80);
  568.   for (i = 0; i < 25; i++)
  569.     VGAwCR (i, par->CRTC[i]);
  571.   for (i = 0; i < 9; i++)
  572.     VGAwGR (i, par->Graphics[i]);
  574.   VGAenablePalette();
  576.   for (i = 0; i < 21; i++)
  577.     VGAwATTR (i, par->Attribute[i]);
  579.   VGAdisablePalette();
  580. }
  582. static void neofb_set_par (struct neofb_info       *info,
  583.    const struct neofb_par  *par)
  584. {
  585.   unsigned char temp;
  586.   int i;
  587.   int clock_hi = 0;
  588.     
  589.   DBG("neofb_set_par");
  591.   neoUnlock();
  593.   vgaHWProtect (1); /* Blank the screen */
  595.   /* linear colormap for non palettized modes */
  596.   switch (par->depth)
  597.     {
  598.     case 8:
  599.       break;
  600.     case 16:
  601.       for (i=0; i<64; i++)
  602. {
  603.   outb(i, 0x3c8);
  604.   
  605.   outb(i << 1, 0x3c9);
  606.   outb(i, 0x3c9);
  607.   outb(i << 1, 0x3c9);
  608. }
  609.       break;
  610.     case 24:
  611. #ifdef NO_32BIT_SUPPORT_YET
  612.     case 32:
  613. #endif
  614.       for (i=0; i<256; i++)
  615. {
  616.   outb(i, 0x3c8);
  617.   
  618.   outb(i, 0x3c9);
  619.   outb(i, 0x3c9);
  620.   outb(i, 0x3c9);
  621. }
  622.       break;
  623.     }
  624.     
  625.   /* alread unlocked above */
  626.   /* BOGUS  VGAwGR (0x09, 0x26);*/
  627.     
  628.   /* don't know what this is, but it's 0 from bootup anyway */
  629.   VGAwGR (0x15, 0x00);
  631.   /* was set to 0x01 by my bios in text and vesa modes */
  632.   VGAwGR (0x0A, par->GeneralLockReg);
  634.   /*
  635.    * The color mode needs to be set before calling vgaHWRestore
  636.    * to ensure the DAC is initialized properly.
  637.    *
  638.    * NOTE: Make sure we don't change bits make sure we don't change
  639.    * any reserved bits.
  640.    */
  641.   temp = VGArGR(0x90);
  642.   switch (info->accel)
  643.     {
  644.     case FB_ACCEL_NEOMAGIC_NM2070:
  645.       temp &= 0xF0; /* Save bits 7:4 */
  646.       temp |= (par->ExtColorModeSelect & ~0xF0);
  647.       break;
  648.     case FB_ACCEL_NEOMAGIC_NM2090:
  649.     case FB_ACCEL_NEOMAGIC_NM2093:
  650.     case FB_ACCEL_NEOMAGIC_NM2097:
  651.     case FB_ACCEL_NEOMAGIC_NM2160:
  652.     case FB_ACCEL_NEOMAGIC_NM2200:
  653.     case FB_ACCEL_NEOMAGIC_NM2230:
  654.     case FB_ACCEL_NEOMAGIC_NM2360:
  655.     case FB_ACCEL_NEOMAGIC_NM2380:
  656.       temp &= 0x70; /* Save bits 6:4 */
  657.       temp |= (par->ExtColorModeSelect & ~0x70);
  658.       break;
  659.     }
  661.   VGAwGR(0x90,temp);
  663.   /*
  664.    * In some rare cases a lockup might occur if we don't delay
  665.    * here. (Reported by Miles Lane)
  666.    */
  667.   //mdelay(200);
  669.   /*
  670.    * Disable horizontal and vertical graphics and text expansions so
  671.    * that vgaHWRestore works properly.
  672.    */
  673.   temp = VGArGR(0x25);
  674.   temp &= 0x39;
  675.   VGAwGR (0x25, temp);
  677.   /*
  678.    * Sleep for 200ms to make sure that the two operations above have
  679.    * had time to take effect.
  680.    */
  681.   mdelay(200);
  683.   /*
  684.    * This function handles restoring the generic VGA registers.  */
  685.   vgaHWRestore (info, par);
  688.   VGAwGR(0x0E, par->ExtCRTDispAddr);
  689.   VGAwGR(0x0F, par->ExtCRTOffset);
  690.   temp = VGArGR(0x10);
  691.   temp &= 0x0F; /* Save bits 3:0 */
  692.   temp |= (par->SysIfaceCntl1 & ~0x0F); /* VESA Bios sets bit 1! */
  693.   VGAwGR(0x10, temp);
  695.   VGAwGR(0x11, par->SysIfaceCntl2);
  696.   VGAwGR(0x15, 0 /*par->SingleAddrPage*/);
  697.   VGAwGR(0x16, 0 /*par->DualAddrPage*/);
  699.   temp = VGArGR(0x20);
  700.   switch (info->accel)
  701.     {
  702.     case FB_ACCEL_NEOMAGIC_NM2070:
  703.       temp &= 0xFC; /* Save bits 7:2 */
  704.       temp |= (par->PanelDispCntlReg1 & ~0xFC);
  705.       break;
  706.     case FB_ACCEL_NEOMAGIC_NM2090:
  707.     case FB_ACCEL_NEOMAGIC_NM2093:
  708.     case FB_ACCEL_NEOMAGIC_NM2097:
  709.     case FB_ACCEL_NEOMAGIC_NM2160:
  710.       temp &= 0xDC; /* Save bits 7:6,4:2 */
  711.       temp |= (par->PanelDispCntlReg1 & ~0xDC);
  712.       break;
  713.     case FB_ACCEL_NEOMAGIC_NM2200:
  714.     case FB_ACCEL_NEOMAGIC_NM2230:
  715.     case FB_ACCEL_NEOMAGIC_NM2360:
  716.     case FB_ACCEL_NEOMAGIC_NM2380:
  717.       temp &= 0x98; /* Save bits 7,4:3 */
  718.       temp |= (par->PanelDispCntlReg1 & ~0x98);
  719.       break;
  720.     }
  721.   VGAwGR(0x20, temp);
  723.   temp = VGArGR(0x25);
  724.   temp &= 0x38; /* Save bits 5:3 */
  725.   temp |= (par->PanelDispCntlReg2 & ~0x38);
  726.   VGAwGR(0x25, temp);
  728.   if (info->accel != FB_ACCEL_NEOMAGIC_NM2070)
  729.     {
  730.       temp = VGArGR(0x30);
  731.       temp &= 0xEF; /* Save bits 7:5 and bits 3:0 */
  732.       temp |= (par->PanelDispCntlReg3 & ~0xEF);
  733.       VGAwGR(0x30, temp);
  734.     }
  736.   VGAwGR(0x28, par->PanelVertCenterReg1);
  737.   VGAwGR(0x29, par->PanelVertCenterReg2);
  738.   VGAwGR(0x2a, par->PanelVertCenterReg3);
  740.   if (info->accel != FB_ACCEL_NEOMAGIC_NM2070)
  741.     {
  742.       VGAwGR(0x32, par->PanelVertCenterReg4);
  743.       VGAwGR(0x33, par->PanelHorizCenterReg1);
  744.       VGAwGR(0x34, par->PanelHorizCenterReg2);
  745.       VGAwGR(0x35, par->PanelHorizCenterReg3);
  746.     }
  748.   if (info->accel == FB_ACCEL_NEOMAGIC_NM2160)
  749.     VGAwGR(0x36, par->PanelHorizCenterReg4);
  751.   if (info->accel == FB_ACCEL_NEOMAGIC_NM2200 ||
  752.       info->accel == FB_ACCEL_NEOMAGIC_NM2230 ||
  753.       info->accel == FB_ACCEL_NEOMAGIC_NM2360 ||
  754.       info->accel == FB_ACCEL_NEOMAGIC_NM2380)
  755.     {
  756.       VGAwGR(0x36, par->PanelHorizCenterReg4);
  757.       VGAwGR(0x37, par->PanelVertCenterReg5);
  758.       VGAwGR(0x38, par->PanelHorizCenterReg5);
  760.       clock_hi = 1;
  761.     }
  763.   /* Program VCLK3 if needed. */
  764.   if (par->ProgramVCLK
  765.       && ((VGArGR(0x9B) != par->VCLK3NumeratorLow)
  766.   || (VGArGR(0x9F) !=  par->VCLK3Denominator)
  767.   || (clock_hi && ((VGArGR(0x8F) & ~0x0f)
  768.    != (par->VCLK3NumeratorHigh & ~0x0F)))))
  769.     {
  770.       VGAwGR(0x9B, par->VCLK3NumeratorLow);
  771.       if (clock_hi)
  772. {
  773.   temp = VGArGR(0x8F);
  774.   temp &= 0x0F; /* Save bits 3:0 */
  775.   temp |= (par->VCLK3NumeratorHigh & ~0x0F);
  776.   VGAwGR(0x8F, temp);
  777. }
  778.       VGAwGR(0x9F, par->VCLK3Denominator);
  779.     }
  781.   if (par->biosMode)
  782.     VGAwCR(0x23, par->biosMode);
  783.     
  784.   VGAwGR (0x93, 0xc0); /* Gives 5x faster framebuffer writes !!! */
  786.   /* Program vertical extension register */
  787.   if (info->accel == FB_ACCEL_NEOMAGIC_NM2200 ||
  788.       info->accel == FB_ACCEL_NEOMAGIC_NM2230 ||
  789.       info->accel == FB_ACCEL_NEOMAGIC_NM2360 ||
  790.       info->accel == FB_ACCEL_NEOMAGIC_NM2380)
  791.     {
  792.       VGAwCR(0x70, par->VerticalExt);
  793.     }
  796.   vgaHWProtect (0); /* Turn on screen */
  798.   /* Calling this also locks offset registers required in update_start */
  799.   neoLock();
  800. }
  802. static void neofb_update_start (struct neofb_info *info, struct fb_var_screeninfo *var)
  803. {
  804.   int oldExtCRTDispAddr;
  805.   int Base; 
  807.   DBG("neofb_update_start");
  809.   Base = (var->yoffset * var->xres_virtual + var->xoffset) >> 2;
  810.   Base *= (var->bits_per_pixel + 7) / 8;
  812.   neoUnlock();
  814.   /*
  815.    * These are the generic starting address registers.
  816.    */
  817.   VGAwCR(0x0C, (Base & 0x00FF00) >> 8);
  818.   VGAwCR(0x0D, (Base & 0x00FF));
  820.   /*
  821.    * Make sure we don't clobber some other bits that might already
  822.    * have been set. NOTE: NM2200 has a writable bit 3, but it shouldn't
  823.    * be needed.
  824.    */
  825.   oldExtCRTDispAddr = VGArGR(0x0E);
  826.   VGAwGR(0x0E,(((Base >> 16) & 0x0f) | (oldExtCRTDispAddr & 0xf0)));
  828.   neoLock();
  829. }
  831. /*
  832.  * Set the Colormap
  833.  */
  834. static int neofb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  835.   struct fb_info *fb)
  836. {
  837.   struct neofb_info *info = (struct neofb_info *)fb;
  838.   struct display* disp = (con < 0) ? fb->disp : (fb_display + con);
  839.   struct fb_cmap *dcmap = &disp->cmap;
  840.   int err = 0;
  842.   /* no colormap allocated? */
  843.   if (!dcmap->len)
  844.     {
  845.       int size;
  847.       if (fb->var.bits_per_pixel == 8)
  848. size = NR_PALETTE;
  849.       else
  850. size = 32;
  852.       err = fb_alloc_cmap (dcmap, size, 0);
  853.     }
  855.   /*
  856.    * we should be able to remove this test once fbcon has been
  857.    * "improved" --rmk
  858.    */
  859.   if (!err && con == info->currcon)
  860.     {
  861.       err = fb_set_cmap (cmap, kspc, neo_setcolreg, fb);
  862.       dcmap = &fb->cmap;
  863.     }
  865.   if (!err)
  866.     fb_copy_cmap (cmap, dcmap, kspc ? 0 : 1);
  868.   return err;
  869. }
  871. /*
  872.  * neoCalcVCLK --
  873.  *
  874.  * Determine the closest clock frequency to the one requested.
  875.  */
  876. #define REF_FREQ 0xe517  /* 14.31818 in 20.12 fixed point */
  877. #define MAX_N 127
  878. #define MAX_D 31
  879. #define MAX_F 1
  881. static void neoCalcVCLK (const struct neofb_info *info, struct neofb_par *par, long freq)
  882. {
  883.   int n, d, f;
  884.   int n_best = 0, d_best = 0, f_best = 0;
  885.   long f_best_diff = (0x7ffff << 12); /* 20.12 */
  886.   long f_target = (freq << 12) / 1000; /* 20.12 */
  888.   for (f = 0; f <= MAX_F; f++)
  889.     for (n = 0; n <= MAX_N; n++)
  890.       for (d = 0; d <= MAX_D; d++)
  891. {
  892.           long f_out;  /* 20.12 */
  893.           long f_diff; /* 20.12 */
  895.   f_out = ((((n+1) << 12)  /  ((d+1)*(1<<f))) >> 12)  *  REF_FREQ;
  896.   f_diff = abs(f_out-f_target);
  897.   if (f_diff < f_best_diff)
  898.     {
  899.       f_best_diff = f_diff;
  900.       n_best = n;
  901.       d_best = d;
  902.       f_best = f;
  903.     }
  904. }
  906.   if (info->accel == FB_ACCEL_NEOMAGIC_NM2200 ||
  907.       info->accel == FB_ACCEL_NEOMAGIC_NM2230 ||
  908.       info->accel == FB_ACCEL_NEOMAGIC_NM2360 ||
  909.       info->accel == FB_ACCEL_NEOMAGIC_NM2380)
  910.     {
  911.       /* NOT_DONE:  We are trying the full range of the 2200 clock.
  912.  We should be able to try n up to 2047 */
  913.       par->VCLK3NumeratorLow  = n_best;
  914.       par->VCLK3NumeratorHigh = (f_best << 7);
  915.     }
  916.   else
  917.     par->VCLK3NumeratorLow  = n_best | (f_best << 7);
  919.   par->VCLK3Denominator = d_best;
  921. #ifdef NEOFB_DEBUG
  922.   printk ("neoVCLK: f:%d NumLow=%d NumHi=%d Den=%d Df=%dn",
  923.   f_target >> 12,
  924.   par->VCLK3NumeratorLow,
  925.   par->VCLK3NumeratorHigh,
  926.   par->VCLK3Denominator,
  927.   f_best_diff >> 12);
  928. #endif
  929. }
  931. /*
  932.  * vgaHWInit --
  933.  *      Handle the initialization, etc. of a screen.
  934.  *      Return FALSE on failure.
  935.  */
  937. static int vgaHWInit (const struct fb_var_screeninfo *var,
  938.       const struct neofb_info        *info,
  939.       struct neofb_par               *par,
  940.       struct xtimings                *timings)
  941. {
  942.   par->MiscOutReg = 0x23;
  944.   if (!(timings->sync & FB_SYNC_HOR_HIGH_ACT))
  945.     par->MiscOutReg |= 0x40;
  947.   if (!(timings->sync & FB_SYNC_VERT_HIGH_ACT))
  948.     par->MiscOutReg |= 0x80;
  949.     
  950.   /*
  951.    * Time Sequencer
  952.    */
  953.   par->Sequencer[0] = 0x00;
  954.   par->Sequencer[1] = 0x01;
  955.   par->Sequencer[2] = 0x0F;
  956.   par->Sequencer[3] = 0x00;                             /* Font select */
  957.   par->Sequencer[4] = 0x0E;                             /* Misc */
  959.   /*
  960.    * CRTC Controller
  961.    */
  962.   par->CRTC[0]  = (timings->HTotal >> 3) - 5;
  963.   par->CRTC[1]  = (timings->HDisplay >> 3) - 1;
  964.   par->CRTC[2]  = (timings->HDisplay >> 3) - 1;
  965.   par->CRTC[3]  = (((timings->HTotal >> 3) - 1) & 0x1F) | 0x80;
  966.   par->CRTC[4]  = (timings->HSyncStart >> 3);
  967.   par->CRTC[5]  = ((((timings->HTotal >> 3) - 1) & 0x20) << 2)
  968.     | (((timings->HSyncEnd >> 3)) & 0x1F);
  969.   par->CRTC[6]  = (timings->VTotal - 2) & 0xFF;
  970.   par->CRTC[7]  = (((timings->VTotal - 2) & 0x100) >> 8)
  971.     | (((timings->VDisplay - 1) & 0x100) >> 7)
  972.     | ((timings->VSyncStart & 0x100) >> 6)
  973.     | (((timings->VDisplay - 1) & 0x100) >> 5)
  974.     | 0x10
  975.     | (((timings->VTotal - 2) & 0x200)   >> 4)
  976.     | (((timings->VDisplay - 1) & 0x200) >> 3)
  977.     | ((timings->VSyncStart & 0x200) >> 2);
  978.   par->CRTC[8]  = 0x00;
  979.   par->CRTC[9]  = (((timings->VDisplay - 1) & 0x200) >> 4) | 0x40;
  981.   if (timings->dblscan)
  982.     par->CRTC[9] |= 0x80;
  984.   par->CRTC[10] = 0x00;
  985.   par->CRTC[11] = 0x00;
  986.   par->CRTC[12] = 0x00;
  987.   par->CRTC[13] = 0x00;
  988.   par->CRTC[14] = 0x00;
  989.   par->CRTC[15] = 0x00;
  990.   par->CRTC[16] = timings->VSyncStart & 0xFF;
  991.   par->CRTC[17] = (timings->VSyncEnd & 0x0F) | 0x20;
  992.   par->CRTC[18] = (timings->VDisplay - 1) & 0xFF;
  993.   par->CRTC[19] = var->xres_virtual >> 4;
  994.   par->CRTC[20] = 0x00;
  995.   par->CRTC[21] = (timings->VDisplay - 1) & 0xFF; 
  996.   par->CRTC[22] = (timings->VTotal - 1) & 0xFF;
  997.   par->CRTC[23] = 0xC3;
  998.   par->CRTC[24] = 0xFF;
  1000.   /*
  1001.    * are these unnecessary?
  1002.    * vgaHWHBlankKGA(mode, regp, 0, KGA_FIX_OVERSCAN | KGA_ENABLE_ON_ZERO);
  1003.    * vgaHWVBlankKGA(mode, regp, 0, KGA_FIX_OVERSCAN | KGA_ENABLE_ON_ZERO);
  1004.    */
  1006.   /*
  1007.    * Graphics Display Controller
  1008.    */
  1009.   par->Graphics[0] = 0x00;
  1010.   par->Graphics[1] = 0x00;
  1011.   par->Graphics[2] = 0x00;
  1012.   par->Graphics[3] = 0x00;
  1013.   par->Graphics[4] = 0x00;
  1014.   par->Graphics[5] = 0x40;
  1015.   par->Graphics[6] = 0x05;   /* only map 64k VGA memory !!!! */
  1016.   par->Graphics[7] = 0x0F;
  1017.   par->Graphics[8] = 0xFF;
  1018.   
  1020.   par->Attribute[0]  = 0x00; /* standard colormap translation */
  1021.   par->Attribute[1]  = 0x01;
  1022.   par->Attribute[2]  = 0x02;
  1023.   par->Attribute[3]  = 0x03;
  1024.   par->Attribute[4]  = 0x04;
  1025.   par->Attribute[5]  = 0x05;
  1026.   par->Attribute[6]  = 0x06;
  1027.   par->Attribute[7]  = 0x07;
  1028.   par->Attribute[8]  = 0x08;
  1029.   par->Attribute[9]  = 0x09;
  1030.   par->Attribute[10] = 0x0A;
  1031.   par->Attribute[11] = 0x0B;
  1032.   par->Attribute[12] = 0x0C;
  1033.   par->Attribute[13] = 0x0D;
  1034.   par->Attribute[14] = 0x0E;
  1035.   par->Attribute[15] = 0x0F;
  1036.   par->Attribute[16] = 0x41;
  1037.   par->Attribute[17] = 0xFF;
  1038.   par->Attribute[18] = 0x0F;
  1039.   par->Attribute[19] = 0x00;
  1040.   par->Attribute[20] = 0x00;
  1042.   return 0;
  1043. }
  1045. static int neofb_decode_var (struct fb_var_screeninfo        *var,
  1046.                              const struct neofb_info         *info,
  1047.                              struct neofb_par                *par)
  1048. {
  1049.   struct xtimings timings;
  1050.   int lcd_stretch;
  1051.   int hoffset, voffset;
  1052.   int memlen, vramlen;
  1053.   int mode_ok = 0;
  1054.   unsigned int pixclock = var->pixclock;
  1056.   DBG("neofb_decode_var");
  1058.   if (!pixclock) pixclock = 10000; /* 10ns = 100MHz */
  1059.   timings.pixclock = 1000000000 / pixclock;
  1060.   if (timings.pixclock < 1) timings.pixclock = 1;
  1061.   timings.dblscan = var->vmode & FB_VMODE_DOUBLE;
  1062.   timings.interlaced = var->vmode & FB_VMODE_INTERLACED;
  1063.   timings.HDisplay = var->xres;
  1064.   timings.HSyncStart = timings.HDisplay + var->right_margin;
  1065.   timings.HSyncEnd = timings.HSyncStart + var->hsync_len;
  1066.   timings.HTotal = timings.HSyncEnd + var->left_margin;
  1067.   timings.VDisplay = var->yres;
  1068.   timings.VSyncStart = timings.VDisplay + var->lower_margin;
  1069.   timings.VSyncEnd = timings.VSyncStart + var->vsync_len;
  1070.   timings.VTotal = timings.VSyncEnd + var->upper_margin;
  1071.   timings.sync = var->sync;
  1073.   if (timings.pixclock > info->maxClock)
  1074.     return -EINVAL;
  1076.   /* Is the mode larger than the LCD panel? */
  1077.   if ((var->xres > info->NeoPanelWidth) ||
  1078.       (var->yres > info->NeoPanelHeight))
  1079.     {
  1080.       printk (KERN_INFO "Mode (%dx%d) larger than the LCD panel (%dx%d)n",
  1081.       var->xres,
  1082.       var->yres,
  1083.       info->NeoPanelWidth,
  1084.       info->NeoPanelHeight);
  1085.       return -EINVAL;
  1086.     }
  1088.   /* Is the mode one of the acceptable sizes? */
  1089.   switch (var->xres)
  1090.     {
  1091.     case 1280:
  1092.       if (var->yres == 1024)
  1093. mode_ok = 1;
  1094.       break;
  1095.     case 1024:
  1096.       if (var->yres == 768)
  1097. mode_ok = 1;
  1098.       break;
  1099.     case  800:
  1100.       if (var->yres == 600)
  1101. mode_ok = 1;
  1102.       break;
  1103.     case  640:
  1104.       if (var->yres == 480)
  1105. mode_ok = 1;
  1106.       break;
  1107.     }
  1109.   if (!mode_ok)
  1110.     {
  1111.       printk (KERN_INFO "Mode (%dx%d) won't display properly on LCDn",
  1112.       var->xres, var->yres);
  1113.       return -EINVAL;
  1114.     }
  1117.   switch (var->bits_per_pixel)
  1118.     {
  1119. #ifdef FBCON_HAS_CFB8
  1120.     case 8:
  1121.       break;
  1122. #endif
  1124. #ifdef FBCON_HAS_CFB16
  1125.     case 16:
  1126.       break;
  1127. #endif
  1129. #ifdef FBCON_HAS_CFB24
  1130.     case 24:
  1131.       break;
  1132. #endif
  1134. #ifdef NO_32BIT_SUPPORT_YET
  1135. # ifdef FBCON_HAS_CFB32
  1136.     case 32:
  1137.       break;
  1138. # endif
  1139. #endif
  1141.     default:
  1142.       return -EINVAL;
  1143.     }
  1145.   par->depth = var->bits_per_pixel;
  1147.   vramlen = info->video.len;
  1148.   if (vramlen > 4*1024*1024)
  1149.     vramlen = 4*1024*1024;
  1151.   if (var->yres_virtual < var->yres)
  1152.     var->yres_virtual = var->yres;
  1153.   if (var->xres_virtual < var->xres)
  1154.     var->xres_virtual = var->xres;
  1156.   memlen = var->xres_virtual * var->bits_per_pixel * var->yres_virtual / 8;
  1157.   if (memlen > vramlen)
  1158.     {
  1159.       var->yres_virtual = vramlen * 8 / (var->xres_virtual * var->bits_per_pixel);
  1160.       memlen = var->xres_virtual * var->bits_per_pixel * var->yres_virtual / 8;
  1161.     }
  1163.   /* we must round yres/xres down, we already rounded y/xres_virtual up
  1164.      if it was possible. We should return -EINVAL, but I disagree */
  1165.   if (var->yres_virtual < var->yres)
  1166.     var->yres = var->yres_virtual;
  1167.   if (var->xres_virtual < var->xres)
  1168.     var->xres = var->xres_virtual;
  1169.   if (var->xoffset + var->xres > var->xres_virtual)
  1170.     var->xoffset = var->xres_virtual - var->xres;
  1171.   if (var->yoffset + var->yres > var->yres_virtual)
  1172.     var->yoffset = var->yres_virtual - var->yres;
  1175.   /*
  1176.    * This will allocate the datastructure and initialize all of the
  1177.    * generic VGA registers.
  1178.    */
  1180.   if (vgaHWInit (var, info, par, &timings))
  1181.     return -EINVAL;
  1183.   /*
  1184.    * The default value assigned by vgaHW.c is 0x41, but this does
  1185.    * not work for NeoMagic.
  1186.    */
  1187.   par->Attribute[16] = 0x01;
  1189.   switch (var->bits_per_pixel)
  1190.     {
  1191.     case  8:
  1192.       par->CRTC[0x13]   = var->xres_virtual >> 3;
  1193.       par->ExtCRTOffset = var->xres_virtual >> 11;
  1194.       par->ExtColorModeSelect = 0x11;
  1195.       break;
  1196.     case 16:
  1197.       par->CRTC[0x13]   = var->xres_virtual >> 2;
  1198.       par->ExtCRTOffset = var->xres_virtual >> 10;
  1199.       par->ExtColorModeSelect = 0x13;
  1200.       break;
  1201.     case 24:
  1202.       par->CRTC[0x13]   = (var->xres_virtual * 3) >> 3;
  1203.       par->ExtCRTOffset = (var->xres_virtual * 3) >> 11;
  1204.       par->ExtColorModeSelect = 0x14;
  1205.       break;
  1206. #ifdef NO_32BIT_SUPPORT_YET
  1207.     case 32: /* FIXME: guessed values */
  1208.       par->CRTC[0x13]   = var->xres_virtual >> 1;
  1209.       par->ExtCRTOffset = var->xres_virtual >> 9;
  1210.       par->ExtColorModeSelect = 0x15;
  1211.       break;
  1212. #endif
  1213.     default:
  1214.       break;
  1215.     }
  1217.   par->ExtCRTDispAddr = 0x10;
  1219.   /* Vertical Extension */
  1220.   par->VerticalExt = (((timings.VTotal -2) & 0x400) >> 10 )
  1221.     | (((timings.VDisplay -1) & 0x400) >> 9 )
  1222.     | (((timings.VSyncStart) & 0x400) >> 8 )
  1223.     | (((timings.VSyncStart) & 0x400) >> 7 );
  1225.   /* Fast write bursts on unless disabled. */
  1226.   if (info->pci_burst)
  1227.     par->SysIfaceCntl1 = 0x30; 
  1228.   else
  1229.     par->SysIfaceCntl1 = 0x00; 
  1231.   par->SysIfaceCntl2 = 0xc0; /* VESA Bios sets this to 0x80! */
  1233.   /* Enable any user specified display devices. */
  1234.   par->PanelDispCntlReg1 = 0x00;
  1235.   if (info->internal_display)
  1236.     par->PanelDispCntlReg1 |= 0x02;
  1237.   if (info->external_display)
  1238.     par->PanelDispCntlReg1 |= 0x01;
  1240.   /* If the user did not specify any display devices, then... */
  1241.   if (par->PanelDispCntlReg1 == 0x00) {
  1242.     /* Default to internal (i.e., LCD) only. */
  1243.     par->PanelDispCntlReg1 |= 0x02;
  1244.   }
  1246.   /* If we are using a fixed mode, then tell the chip we are. */
  1247.   switch (var->xres)
  1248.     {
  1249.     case 1280:
  1250.       par->PanelDispCntlReg1 |= 0x60;
  1251.       break;
  1252.     case 1024:
  1253.       par->PanelDispCntlReg1 |= 0x40;
  1254.       break;
  1255.     case 800:
  1256.       par->PanelDispCntlReg1 |= 0x20;
  1257.       break;
  1258.     case 640:
  1259.     default:
  1260.       break;
  1261.     }
  1262.   
  1263.   /* Setup shadow register locking. */
  1264.   switch (par->PanelDispCntlReg1 & 0x03)
  1265.     {
  1266.     case 0x01: /* External CRT only mode: */
  1267.       par->GeneralLockReg = 0x00;
  1268.       /* We need to program the VCLK for external display only mode. */
  1269.       par->ProgramVCLK = 1;
  1270.       break;
  1271.     case 0x02: /* Internal LCD only mode: */
  1272.     case 0x03: /* Simultaneous internal/external (LCD/CRT) mode: */
  1273.       par->GeneralLockReg = 0x01;
  1274.       /* Don't program the VCLK when using the LCD. */
  1275.       par->ProgramVCLK = 0;
  1276.       break;
  1277.     }
  1279.   /*
  1280.    * If the screen is to be stretched, turn on stretching for the
  1281.    * various modes.
  1282.    *
  1283.    * OPTION_LCD_STRETCH means stretching should be turned off!
  1284.    */
  1285.   par->PanelDispCntlReg2 = 0x00;
  1286.   par->PanelDispCntlReg3 = 0x00;
  1288.   if (info->lcd_stretch &&
  1289.       (par->PanelDispCntlReg1 == 0x02) &&  /* LCD only */
  1290.       (var->xres != info->NeoPanelWidth))
  1291.     {
  1292.       switch (var->xres)
  1293. {
  1294. case  320: /* Needs testing.  KEM -- 24 May 98 */
  1295. case  400: /* Needs testing.  KEM -- 24 May 98 */
  1296. case  640:
  1297. case  800:
  1298. case 1024:
  1299.   lcd_stretch = 1;
  1300.   par->PanelDispCntlReg2 |= 0xC6;
  1301.   break;
  1302. default:
  1303.   lcd_stretch = 0;
  1304.   /* No stretching in these modes. */
  1305. }
  1306.     }
  1307.   else
  1308.     lcd_stretch = 0;
  1310.   /*
  1311.    * If the screen is to be centerd, turn on the centering for the
  1312.    * various modes.
  1313.    */
  1314.   par->PanelVertCenterReg1  = 0x00;
  1315.   par->PanelVertCenterReg2  = 0x00;
  1316.   par->PanelVertCenterReg3  = 0x00;
  1317.   par->PanelVertCenterReg4  = 0x00;
  1318.   par->PanelVertCenterReg5  = 0x00;
  1319.   par->PanelHorizCenterReg1 = 0x00;
  1320.   par->PanelHorizCenterReg2 = 0x00;
  1321.   par->PanelHorizCenterReg3 = 0x00;
  1322.   par->PanelHorizCenterReg4 = 0x00;
  1323.   par->PanelHorizCenterReg5 = 0x00;
  1326.   if (par->PanelDispCntlReg1 & 0x02)
  1327.     {
  1328.       if (var->xres == info->NeoPanelWidth)
  1329. {
  1330.   /*
  1331.    * No centering required when the requested display width
  1332.    * equals the panel width.
  1333.    */
  1334. }
  1335.       else
  1336. {
  1337.   par->PanelDispCntlReg2 |= 0x01;
  1338.   par->PanelDispCntlReg3 |= 0x10;
  1340.   /* Calculate the horizontal and vertical offsets. */
  1341.   if (!lcd_stretch)
  1342.     {
  1343.       hoffset = ((info->NeoPanelWidth - var->xres) >> 4) - 1;
  1344.       voffset = ((info->NeoPanelHeight - var->yres) >> 1) - 2;
  1345.     }
  1346.   else
  1347.     {
  1348.       /* Stretched modes cannot be centered. */
  1349.       hoffset = 0;
  1350.       voffset = 0;
  1351.     }
  1353.   switch (var->xres)
  1354.     {
  1355.     case  320: /* Needs testing.  KEM -- 24 May 98 */
  1356.       par->PanelHorizCenterReg3 = hoffset;
  1357.       par->PanelVertCenterReg2  = voffset;
  1358.       break;
  1359.     case  400: /* Needs testing.  KEM -- 24 May 98 */
  1360.       par->PanelHorizCenterReg4 = hoffset;
  1361.       par->PanelVertCenterReg1  = voffset;
  1362.       break;
  1363.     case  640:
  1364.       par->PanelHorizCenterReg1 = hoffset;
  1365.       par->PanelVertCenterReg3  = voffset;
  1366.       break;
  1367.     case  800:
  1368.       par->PanelHorizCenterReg2 = hoffset;
  1369.       par->PanelVertCenterReg4  = voffset;
  1370.       break;
  1371.     case 1024:
  1372.       par->PanelHorizCenterReg5 = hoffset;
  1373.       par->PanelVertCenterReg5  = voffset;
  1374.       break;
  1375.     case 1280:
  1376.     default:
  1377.       /* No centering in these modes. */
  1378.       break;
  1379.     }
  1380. }
  1381.     }
  1383.   par->biosMode = neoFindMode (var->xres, var->yres, var->bits_per_pixel);
  1384.     
  1385.   /*
  1386.    * Calculate the VCLK that most closely matches the requested dot
  1387.    * clock.
  1388.    */
  1389.   neoCalcVCLK (info, par, timings.pixclock);
  1391.   /* Since we program the clocks ourselves, always use VCLK3. */
  1392.   par->MiscOutReg |= 0x0C;
  1394.   return 0;
  1395. }
  1397. static int neofb_set_var (struct fb_var_screeninfo *var, int con,
  1398.                           struct fb_info *fb)
  1399. {
  1400.   struct neofb_info *info = (struct neofb_info *)fb;
  1401.   struct display *display;
  1402.   struct neofb_par par;
  1403.   int err, chgvar = 0;
  1405.   DBG("neofb_set_var");
  1407.   err = neofb_decode_var (var, info, &par);
  1408.   if (err)
  1409.     return err;
  1411.   if (var->activate & FB_ACTIVATE_TEST)
  1412.     return 0;
  1414.   if (con < 0)
  1415.     {
  1416.       display = fb->disp;
  1417.       chgvar = 0;
  1418.     }
  1419.   else
  1420.     {
  1421.       display = fb_display + con;
  1423.       if (fb->var.xres != var->xres)
  1424. chgvar = 1;
  1425.       if (fb->var.yres != var->yres)
  1426. chgvar = 1;
  1427.       if (fb->var.xres_virtual != var->xres_virtual)
  1428. chgvar = 1;
  1429.       if (fb->var.yres_virtual != var->yres_virtual)
  1430. chgvar = 1;
  1431.       if (fb->var.bits_per_pixel != var->bits_per_pixel)
  1432. chgvar = 1;
  1433.     }
  1435.   if (!info->neo2200)
  1436.     var->accel_flags &= ~FB_ACCELF_TEXT;
  1438.   var->red.msb_right = 0;
  1439.   var->green.msb_right = 0;
  1440.   var->blue.msb_right = 0;
  1442.   switch (var->bits_per_pixel)
  1443.     {
  1444. #ifdef FBCON_HAS_CFB8
  1445.     case 8: /* PSEUDOCOLOUR, 256 */
  1446.       var->transp.offset   = 0;
  1447.       var->transp.length   = 0;
  1448.       var->red.offset      = 0;
  1449.       var->red.length      = 8;
  1450.       var->green.offset    = 0;
  1451.       var->green.length    = 8;
  1452.       var->blue.offset    = 0;
  1453.       var->blue.length    = 8;
  1454.       
  1455.       fb->fix.visual       = FB_VISUAL_PSEUDOCOLOR;
  1456.       info->dispsw         = &fbcon_cfb8;
  1457.       display->dispsw_data = NULL;
  1458.       display->next_line   = var->xres_virtual;
  1459.       break;
  1460. #endif
  1462. #ifdef FBCON_HAS_CFB16
  1463.     case 16: /* DIRECTCOLOUR, 64k */
  1464.       var->transp.offset   = 0;
  1465.       var->transp.length   = 0;
  1466.       var->red.offset      = 11;
  1467.       var->red.length      = 5;
  1468.       var->green.offset    = 5;
  1469.       var->green.length    = 6;
  1470.       var->blue.offset     = 0;
  1471.       var->blue.length     = 5;
  1473.       fb->fix.visual       = FB_VISUAL_DIRECTCOLOR;
  1474.       info->dispsw         = &fbcon_cfb16;
  1475.       display->dispsw_data = fb->pseudo_palette;
  1476.       display->next_line   = var->xres_virtual * 2;
  1477.       break;
  1478. #endif
  1480. #ifdef FBCON_HAS_CFB24
  1481.     case 24: /* TRUECOLOUR, 16m */
  1482.       var->transp.offset   = 0;
  1483.       var->transp.length   = 0;
  1484.       var->red.offset      = 16;
  1485.       var->red.length      = 8;
  1486.       var->green.offset    = 8;
  1487.       var->green.length    = 8;
  1488.       var->blue.offset     = 0;
  1489.       var->blue.length     = 8;
  1491.       fb->fix.visual       = FB_VISUAL_TRUECOLOR;
  1492.       info->dispsw         = &fbcon_cfb24;
  1493.       display->dispsw_data = fb->pseudo_palette;
  1494.       display->next_line   = var->xres_virtual * 3;
  1496.       var->accel_flags    &= ~FB_ACCELF_TEXT;
  1497.       break;
  1498. #endif
  1500. #ifdef NO_32BIT_SUPPORT_YET
  1501. # ifdef FBCON_HAS_CFB32
  1502.     case 32: /* TRUECOLOUR, 16m */
  1503.       var->transp.offset   = 24;
  1504.       var->transp.length   = 8;
  1505.       var->red.offset      = 16;
  1506.       var->red.length      = 8;
  1507.       var->green.offset    = 8;
  1508.       var->green.length    = 8;
  1509.       var->blue.offset     = 0;
  1510.       var->blue.length     = 8;
  1512.       fb->fix.visual       = FB_VISUAL_TRUECOLOR;
  1513.       info->dispsw         = &fbcon_cfb32;
  1514.       display->dispsw_data = fb->pseudo_palette;
  1515.       display->next_line   = var->xres_virtual * 4;
  1517.       var->accel_flags    &= ~FB_ACCELF_TEXT;
  1518.       break;
  1519. # endif
  1520. #endif
  1522.     default:
  1523.       printk (KERN_WARNING "neofb: no support for %dbppn", var->bits_per_pixel);
  1524.       info->dispsw      = &fbcon_dummy;
  1525.       var->accel_flags &= ~FB_ACCELF_TEXT;
  1526.       break;
  1527.     }
  1529.   if (var->accel_flags & FB_ACCELF_TEXT)
  1530.     display->dispsw = &fbcon_neo2200_accel;
  1531.   else
  1532.     display->dispsw = info->dispsw;
  1534.   fb->fix.line_length = display->next_line;
  1536.   display->screen_base    = fb->screen_base;
  1537.   display->line_length    = fb->fix.line_length;
  1538.   display->visual         = fb->fix.visual;
  1539.   display->type           = fb->fix.type;
  1540.   display->type_aux       = fb->fix.type_aux;
  1541.   display->ypanstep       = fb->fix.ypanstep;
  1542.   display->ywrapstep      = fb->fix.ywrapstep;
  1543.   display->can_soft_blank = 1;
  1544.   display->inverse        = 0;
  1546.   fb->var = *var;
  1547.   fb->var.activate &= ~FB_ACTIVATE_ALL;
  1549.   /*
  1550.    * Update the old var.  The fbcon drivers still use this.
  1551.    * Once they are using cfb->fb.var, this can be dropped.
  1552.    * --rmk
  1553.    */
  1554.   display->var = fb->var;
  1556.   /*
  1557.    * If we are setting all the virtual consoles, also set the
  1558.    * defaults used to create new consoles.
  1559.    */
  1560.   if (var->activate & FB_ACTIVATE_ALL)
  1561.     fb->disp->var = fb->var;
  1563.   if (chgvar && fb && fb->changevar)
  1564.     fb->changevar (con);
  1566.   if (con == info->currcon)
  1567.     {
  1568.       if (chgvar || con < 0)
  1569.         neofb_set_par (info, &par);
  1571.       neofb_update_start (info, var);
  1572.       fb_set_cmap (&fb->cmap, 1, neo_setcolreg, fb);
  1574.       if (var->accel_flags & FB_ACCELF_TEXT)
  1575. neo2200_accel_init (info, var);
  1576.     }
  1578.   return 0;
  1579. }
  1581. /*
  1582.  *    Pan or Wrap the Display
  1583.  */
  1584. static int neofb_pan_display (struct fb_var_screeninfo *var, int con,
  1585.       struct fb_info *fb)
  1586. {
  1587.   struct neofb_info *info = (struct neofb_info *)fb;
  1588.   u_int y_bottom;
  1590.   y_bottom = var->yoffset;
  1592.   if (!(var->vmode & FB_VMODE_YWRAP))
  1593.     y_bottom += var->yres;
  1595.   if (var->xoffset > (var->xres_virtual - var->xres))
  1596.     return -EINVAL;
  1597.   if (y_bottom > fb->var.yres_virtual)
  1598.     return -EINVAL;
  1600.   neofb_update_start (info, var);
  1602.   fb->var.xoffset = var->xoffset;
  1603.   fb->var.yoffset = var->yoffset;
  1605.   if (var->vmode & FB_VMODE_YWRAP)
  1606.     fb->var.vmode |= FB_VMODE_YWRAP;
  1607.   else
  1608.     fb->var.vmode &= ~FB_VMODE_YWRAP;
  1610.   return 0;
  1611. }
  1614. /*
  1615.  *    Update the `var' structure (called by fbcon.c)
  1616.  *
  1617.  *    This call looks only at yoffset and the FB_VMODE_YWRAP flag in `var'.
  1618.  *    Since it's called by a kernel driver, no range checking is done.
  1619.  */
  1620. static int neofb_updatevar (int con, struct fb_info *fb)
  1621. {
  1622.   struct neofb_info *info = (struct neofb_info *)fb;
  1624.   neofb_update_start (info, &fb_display[con].var);
  1626.   return 0;
  1627. }
  1629. static int neofb_switch (int con, struct fb_info *fb)
  1630. {
  1631.   struct neofb_info *info = (struct neofb_info *)fb;
  1632.   struct display *disp;
  1633.   struct fb_cmap *cmap;
  1635.   if (info->currcon >= 0)
  1636.     {
  1637.       disp = fb_display + info->currcon;
  1639.       /*
  1640.        * Save the old colormap and video mode.
  1641.        */
  1642.       disp->var = fb->var;
  1643.       if (disp->cmap.len)
  1644. fb_copy_cmap(&fb->cmap, &disp->cmap, 0);
  1645.     }
  1647.   info->currcon = con;
  1648.   disp = fb_display + con;
  1650.   /*
  1651.    * Install the new colormap and change the video mode.  By default,
  1652.    * fbcon sets all the colormaps and video modes to the default
  1653.    * values at bootup.
  1654.    *
  1655.    * Really, we want to set the colourmap size depending on the
  1656.    * depth of the new video mode.  For now, we leave it at its
  1657.    * default 256 entry.
  1658.    */
  1659.   if (disp->cmap.len)
  1660.     cmap = &disp->cmap;
  1661.   else
  1662.     cmap = fb_default_cmap(1 << disp->var.bits_per_pixel);
  1664.   fb_copy_cmap(cmap, &fb->cmap, 0);
  1666.   disp->var.activate = FB_ACTIVATE_NOW;
  1667.   neofb_set_var(&disp->var, con, fb);
  1669.   return 0;
  1670. }
  1672. /*
  1673.  *    (Un)Blank the display.
  1674.  */
  1675. static void neofb_blank (int blank, struct fb_info *fb)
  1676. {
  1677.   //  struct neofb_info *info = (struct neofb_info *)fb;
  1679.   /*
  1680.    *  Blank the screen if blank_mode != 0, else unblank. If
  1681.    *  blank == NULL then the caller blanks by setting the CLUT
  1682.    *  (Color Look Up Table) to all black. Return 0 if blanking
  1683.    *  succeeded, != 0 if un-/blanking failed due to e.g. a
  1684.    *  video mode which doesn't support it. Implements VESA
  1685.    *  suspend and powerdown modes on hardware that supports
  1686.    *  disabling hsync/vsync:
  1687.    *    blank_mode == 2: suspend vsync
  1688.    *    blank_mode == 3: suspend hsync
  1689.    *    blank_mode == 4: powerdown
  1690.    *
  1691.    *  wms...Enable VESA DMPS compatible powerdown mode
  1692.    *  run "setterm -powersave powerdown" to take advantage
  1693.    */
  1694.      
  1695.   switch (blank)
  1696.     {
  1697.     case 4: /* powerdown - both sync lines down */
  1698.       break;
  1699.     case 3: /* hsync off */
  1700.       break;
  1701.     case 2: /* vsync off */
  1702.       break;
  1703.     case 1: /* just software blanking of screen */
  1704.       break;
  1705.     default: /* case 0, or anything else: unblank */
  1706.       break;
  1707.     }
  1708. }
  1710. /*
  1711.  * Get the currently displayed virtual consoles colormap.
  1712.  */
  1713. static int gen_get_cmap (struct fb_cmap *cmap, int kspc, int con, struct fb_info *fb)
  1714. {
  1715.   fb_copy_cmap (&fb->cmap, cmap, kspc ? 0 : 2);
  1716.   return 0;
  1717. }
  1719. /*
  1720.  * Get the currently displayed virtual consoles fixed part of the display.
  1721.  */
  1722. static int gen_get_fix (struct fb_fix_screeninfo *fix, int con, struct fb_info *fb)
  1723. {
  1724.   *fix = fb->fix;
  1725.   return 0;
  1726. }
  1728. /*
  1729.  * Get the current user defined part of the display.
  1730.  */
  1731. static int gen_get_var (struct fb_var_screeninfo *var, int con, struct fb_info *fb)
  1732. {
  1733.   *var = fb->var;
  1734.   return 0;
  1735. }
  1737. static struct fb_ops neofb_ops = {
  1738.   owner:          THIS_MODULE,
  1739.   fb_set_var:     neofb_set_var,
  1740.   fb_set_cmap:    neofb_set_cmap,
  1741.   fb_pan_display: neofb_pan_display,
  1742.   fb_get_fix:     gen_get_fix,
  1743.   fb_get_var:     gen_get_var,
  1744.   fb_get_cmap:    gen_get_cmap,
  1745. };
  1747. /* --------------------------------------------------------------------- */
  1749. static struct fb_var_screeninfo __devinitdata neofb_var640x480x8 = {
  1750. accel_flags: FB_ACCELF_TEXT,
  1751. xres: 640,
  1752. yres: 480,
  1753. xres_virtual:   640,
  1754. yres_virtual:   30000,
  1755. bits_per_pixel: 8,
  1756. pixclock: 39722,
  1757. left_margin: 48,
  1758. right_margin: 16,
  1759. upper_margin: 33,
  1760. lower_margin: 10,
  1761. hsync_len: 96,
  1762. vsync_len: 2,
  1763. sync: 0,
  1764. vmode: FB_VMODE_NONINTERLACED
  1765. };
  1767. static struct fb_var_screeninfo __devinitdata neofb_var800x600x8 = {
  1768. accel_flags: FB_ACCELF_TEXT,
  1769. xres: 800,
  1770. yres: 600,
  1771. xres_virtual:   800,
  1772. yres_virtual:   30000,
  1773. bits_per_pixel: 8,
  1774. pixclock: 25000,
  1775. left_margin: 88,
  1776. right_margin: 40,
  1777. upper_margin: 23,
  1778. lower_margin: 1,
  1779. hsync_len: 128,
  1780. vsync_len: 4,
  1781. sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  1782. vmode: FB_VMODE_NONINTERLACED
  1783. };
  1785. static struct fb_var_screeninfo __devinitdata neofb_var1024x768x8 = {
  1786. accel_flags: FB_ACCELF_TEXT,
  1787. xres: 1024,
  1788. yres: 768,
  1789. xres_virtual:   1024,
  1790. yres_virtual:   30000,
  1791. bits_per_pixel: 8,
  1792. pixclock: 15385,
  1793. left_margin: 160,
  1794. right_margin: 24,
  1795. upper_margin: 29,
  1796. lower_margin: 3,
  1797. hsync_len: 136,
  1798. vsync_len: 6,
  1799. sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  1800. vmode: FB_VMODE_NONINTERLACED
  1801. };
  1803. #ifdef NOT_DONE
  1804. static struct fb_var_screeninfo __devinitdata neofb_var1280x1024x8 = {
  1805. accel_flags: FB_ACCELF_TEXT,
  1806. xres: 1280,
  1807. yres: 1024,
  1808. xres_virtual:   1280,
  1809. yres_virtual:   30000,
  1810. bits_per_pixel: 8,
  1811. pixclock: 9260,
  1812. left_margin: 248,
  1813. right_margin: 48,
  1814. upper_margin: 38,
  1815. lower_margin: 1,
  1816. hsync_len: 112,
  1817. vsync_len: 3,
  1818. sync: FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  1819. vmode: FB_VMODE_NONINTERLACED
  1820. };
  1821. #endif
  1823. static struct fb_var_screeninfo *neofb_var = NULL;
  1826. static int __devinit neo_map_mmio (struct neofb_info *info)
  1827. {
  1828.   DBG("neo_map_mmio");
  1830.   info->mmio.pbase = pci_resource_start (info->pcidev, 1);
  1831.   info->mmio.len   = MMIO_SIZE;
  1833.   if (!request_mem_region (info->mmio.pbase, MMIO_SIZE, "memory mapped I/O"))
  1834.     {
  1835.       printk ("neofb: memory mapped IO in usen");
  1836.       return -EBUSY;
  1837.     }
  1839.   info->mmio.vbase = ioremap (info->mmio.pbase, MMIO_SIZE);
  1840.   if (!info->mmio.vbase)
  1841.     {
  1842.       printk ("neofb: unable to map memory mapped IOn");
  1843.       release_mem_region (info->mmio.pbase, info->mmio.len);
  1844.       return -ENOMEM;
  1845.     }
  1846.   else
  1847.     printk (KERN_INFO "neofb: mapped io at %pn", info->mmio.vbase);
  1849.   info->fb.fix.mmio_start = info->mmio.pbase;
  1850.   info->fb.fix.mmio_len   = info->mmio.len;
  1852.   return 0;
  1853. }
  1855. static void __devinit neo_unmap_mmio (struct neofb_info *info)
  1856. {
  1857.   DBG("neo_unmap_mmio");
  1859.   if (info->mmio.vbase)
  1860.     {
  1861.       iounmap (info->mmio.vbase);
  1862.       info->mmio.vbase = NULL;
  1864.       release_mem_region (info->mmio.pbase, info->mmio.len);
  1865.     }
  1866. }
  1868. static int __devinit neo_map_video (struct neofb_info *info, int video_len)
  1869. {
  1870.   DBG("neo_map_video");
  1872.   info->video.pbase = pci_resource_start (info->pcidev, 0);
  1873.   info->video.len   = video_len;
  1875.   if (!request_mem_region (info->video.pbase, info->video.len, "frame buffer"))
  1876.     {
  1877.       printk ("neofb: frame buffer in usen");
  1878.       return -EBUSY;
  1879.     }
  1881.   info->video.vbase = ioremap (info->video.pbase, info->video.len);
  1882.   if (!info->video.vbase)
  1883.     {
  1884.       printk ("neofb: unable to map screen memoryn");
  1885.       release_mem_region (info->video.pbase, info->video.len);
  1886.       return -ENOMEM;
  1887.     }
  1888.   else
  1889.     printk (KERN_INFO "neofb: mapped framebuffer at %pn", info->video.vbase);
  1891.   info->fb.fix.smem_start = info->video.pbase;
  1892.   info->fb.fix.smem_len   = info->video.len;
  1893.   info->fb.screen_base    = info->video.vbase;
  1895. #ifdef CONFIG_MTRR
  1896.   info->video.mtrr = mtrr_add (info->video.pbase, pci_resource_len (info->pcidev, 0), MTRR_TYPE_WRCOMB, 1);
  1897. #endif
  1899.   /* Clear framebuffer, it's all white in memory after boot */
  1900.   memset (info->video.vbase, 0, info->video.len);
  1902.   return 0;
  1903. }
  1905. static void __devinit neo_unmap_video (struct neofb_info *info)
  1906. {
  1907.   DBG("neo_unmap_video");
  1909.   if (info->video.vbase)
  1910.     {
  1911. #ifdef CONFIG_MTRR
  1912.       mtrr_del (info->video.mtrr, info->video.pbase, info->video.len);
  1913. #endif
  1915.       iounmap (info->video.vbase);
  1916.       info->video.vbase = NULL;
  1917.       info->fb.screen_base = NULL;
  1919.       release_mem_region (info->video.pbase, info->video.len);
  1920.     }
  1921. }
  1923. static int __devinit neo_init_hw (struct neofb_info *info)
  1924. {
  1925.   int videoRam = 896;
  1926.   int maxClock = 65000;
  1927.   int CursorMem = 1024;
  1928.   int CursorOff = 0x100;
  1929.   int linearSize = 1024;
  1930.   int maxWidth = 1024;
  1931.   int maxHeight = 1024;
  1932.   unsigned char type, display;
  1933.   int w;
  1934.     
  1935.   DBG("neo_init_hw");
  1937.   neoUnlock();
  1939. #if 0
  1940.   printk (KERN_DEBUG "--- Neo extended register dump ---n");
  1941.   for (w=0; w<0x85; w++)
  1942.     printk (KERN_DEBUG "CR %p: %pn", (void*)w, (void*)VGArCR (w));
  1943.   for (w=0; w<0xC7; w++)
  1944.     printk (KERN_DEBUG "GR %p: %pn", (void*)w, (void*)VGArGR (w));
  1945. #endif
  1947.   /* Determine the panel type */
  1948.   VGAwGR(0x09,0x26);
  1949.   type = VGArGR(0x21);
  1950.   display = VGArGR(0x20);
  1951.     
  1952.   /* Determine panel width -- used in NeoValidMode. */
  1953.   w = VGArGR(0x20);
  1954.   VGAwGR(0x09,0x00);
  1955.   switch ((w & 0x18) >> 3)
  1956.     {
  1957.     case 0x00:
  1958.       info->NeoPanelWidth  = 640;
  1959.       info->NeoPanelHeight = 480;
  1960.       neofb_var = &neofb_var640x480x8;
  1961.       break;
  1962.     case 0x01:
  1963.       info->NeoPanelWidth  = 800;
  1964.       info->NeoPanelHeight = 600;
  1965.       neofb_var = &neofb_var800x600x8;
  1966.       break;
  1967.     case 0x02:
  1968.       info->NeoPanelWidth  = 1024;
  1969.       info->NeoPanelHeight = 768;
  1970.       neofb_var = &neofb_var1024x768x8;
  1971.       break;
  1972.     case 0x03:
  1973.       /* 1280x1024 panel support needs to be added */
  1974. #ifdef NOT_DONE
  1975.       info->NeoPanelWidth  = 1280;
  1976.       info->NeoPanelHeight = 1024;
  1977.       neofb_var = &neofb_var1280x1024x8;
  1978.       break;
  1979. #else
  1980.       printk (KERN_ERR "neofb: Only 640x480, 800x600 and 1024x768 panels are currently supportedn");
  1981.       return -1;
  1982. #endif
  1983.     default:
  1984.       info->NeoPanelWidth  = 640;
  1985.       info->NeoPanelHeight = 480;
  1986.       neofb_var = &neofb_var640x480x8;
  1987.       break;
  1988.     }
  1990.   printk (KERN_INFO "Panel is a %dx%d %s %s displayn",
  1991.   info->NeoPanelWidth,
  1992.   info->NeoPanelHeight,
  1993.   (type & 0x02) ? "color" : "monochrome",
  1994.   (type & 0x10) ? "TFT" : "dual scan");
  1996.   switch (info->accel)
  1997.     {
  1998.     case FB_ACCEL_NEOMAGIC_NM2070:
  1999.       videoRam   = 896;
  2000.       maxClock   = 65000;
  2001.       CursorMem  = 2048;
  2002.       CursorOff  = 0x100;
  2003.       linearSize = 1024;
  2004.       maxWidth   = 1024;
  2005.       maxHeight  = 1024;
  2006.       break;
  2007.     case FB_ACCEL_NEOMAGIC_NM2090:
  2008.     case FB_ACCEL_NEOMAGIC_NM2093:
  2009.       videoRam   = 1152;
  2010.       maxClock   = 80000;
  2011.       CursorMem  = 2048;
  2012.       CursorOff  = 0x100;
  2013.       linearSize = 2048;
  2014.       maxWidth   = 1024;
  2015.       maxHeight  = 1024;
  2016.       break;
  2017.     case FB_ACCEL_NEOMAGIC_NM2097:
  2018.       videoRam   = 1152;
  2019.       maxClock   = 80000;
  2020.       CursorMem  = 1024;
  2021.       CursorOff  = 0x100;
  2022.       linearSize = 2048;
  2023.       maxWidth   = 1024;
  2024.       maxHeight  = 1024;
  2025.       break;
  2026.     case FB_ACCEL_NEOMAGIC_NM2160:
  2027.       videoRam   = 2048;
  2028.       maxClock   = 90000;
  2029.       CursorMem  = 1024;
  2030.       CursorOff  = 0x100;
  2031.       linearSize = 2048;
  2032.       maxWidth   = 1024;
  2033.       maxHeight  = 1024;
  2034.       break;
  2035.     case FB_ACCEL_NEOMAGIC_NM2200:
  2036.       videoRam   = 2560;
  2037.       maxClock   = 110000;
  2038.       CursorMem  = 1024;
  2039.       CursorOff  = 0x1000;
  2040.       linearSize = 4096;
  2041.       maxWidth   = 1280;
  2042.       maxHeight  = 1024;  /* ???? */
  2044.       info->neo2200 = (Neo2200*) info->mmio.vbase;
  2045.       break;
  2046.     case FB_ACCEL_NEOMAGIC_NM2230:
  2047.       videoRam   = 3008;
  2048.       maxClock   = 110000;
  2049.       CursorMem  = 1024;
  2050.       CursorOff  = 0x1000;
  2051.       linearSize = 4096;
  2052.       maxWidth   = 1280;
  2053.       maxHeight  = 1024;  /* ???? */
  2055.       info->neo2200 = (Neo2200*) info->mmio.vbase;
  2056.       break;
  2057.     case FB_ACCEL_NEOMAGIC_NM2360:
  2058.       videoRam   = 4096;
  2059.       maxClock   = 110000;
  2060.       CursorMem  = 1024;
  2061.       CursorOff  = 0x1000;
  2062.       linearSize = 4096;
  2063.       maxWidth   = 1280;
  2064.       maxHeight  = 1024;  /* ???? */
  2066.       info->neo2200 = (Neo2200*) info->mmio.vbase;
  2067.       break;
  2068.     case FB_ACCEL_NEOMAGIC_NM2380:
  2069.       videoRam   = 6144;
  2070.       maxClock   = 110000;
  2071.       CursorMem  = 1024;
  2072.       CursorOff  = 0x1000;
  2073.       linearSize = 8192;
  2074.       maxWidth   = 1280;
  2075.       maxHeight  = 1024;  /* ???? */
  2077.       info->neo2200 = (Neo2200*) info->mmio.vbase;
  2078.       break;
  2079.     }
  2081.   info->maxClock = maxClock;
  2083.   return videoRam * 1024;
  2084. }
  2087. static struct neofb_info * __devinit neo_alloc_fb_info (struct pci_dev *dev,
  2088. const struct pci_device_id *id)
  2089. {
  2090.   struct neofb_info *info;
  2092.   info = kmalloc (sizeof(struct neofb_info) + sizeof(struct display) +
  2093.   sizeof(u32) * 16, GFP_KERNEL);
  2095.   if (!info)
  2096.     return NULL;
  2098.   memset (info, 0, sizeof(struct neofb_info) + sizeof(struct display));
  2100.   info->currcon = -1;
  2101.   info->pcidev  = dev;
  2102.   info->accel   = id->driver_data;
  2104.   info->pci_burst   = !nopciburst;
  2105.   info->lcd_stretch = !nostretch;
  2107.   if (!internal && !external)
  2108.     {
  2109.       info->internal_display = 1;
  2110.       info->external_display = 0;
  2111.     }
  2112.   else
  2113.     {
  2114.       info->internal_display = internal;
  2115.       info->external_display = external;
  2116.     }
  2118.   switch (info->accel)
  2119.     {
  2120.     case FB_ACCEL_NEOMAGIC_NM2070:
  2121.       sprintf (info->fb.fix.id, "MagicGraph 128");
  2122.       break;
  2123.     case FB_ACCEL_NEOMAGIC_NM2090:
  2124.       sprintf (info->fb.fix.id, "MagicGraph 128V");
  2125.       break;
  2126.     case FB_ACCEL_NEOMAGIC_NM2093:
  2127.       sprintf (info->fb.fix.id, "MagicGraph 128ZV");
  2128.       break;
  2129.     case FB_ACCEL_NEOMAGIC_NM2097:
  2130.       sprintf (info->fb.fix.id, "MagicGraph 128ZV+");
  2131.       break;
  2132.     case FB_ACCEL_NEOMAGIC_NM2160:
  2133.       sprintf (info->fb.fix.id, "MagicGraph 128XD");
  2134.       break;
  2135.     case FB_ACCEL_NEOMAGIC_NM2200:
  2136.       sprintf (info->fb.fix.id, "MagicGraph 256AV");
  2137.       break;
  2138.     case FB_ACCEL_NEOMAGIC_NM2230:
  2139.       sprintf (info->fb.fix.id, "MagicGraph 256AV+");
  2140.       break;
  2141.     case FB_ACCEL_NEOMAGIC_NM2360:
  2142.       sprintf (info->fb.fix.id, "MagicGraph 256ZX");
  2143.       break;
  2144.     case FB_ACCEL_NEOMAGIC_NM2380:
  2145.       sprintf (info->fb.fix.id, "MagicGraph 256XL+");
  2146.       break;
  2147.     }
  2149.   info->fb.fix.type    = FB_TYPE_PACKED_PIXELS;
  2150.   info->fb.fix.type_aux    = 0;
  2151.   info->fb.fix.xpanstep    = 0;
  2152.   info->fb.fix.ypanstep    = 4;
  2153.   info->fb.fix.ywrapstep   = 0;
  2154.   info->fb.fix.accel       = id->driver_data;
  2156.   info->fb.var.nonstd      = 0;
  2157.   info->fb.var.activate    = FB_ACTIVATE_NOW;
  2158.   info->fb.var.height      = -1;
  2159.   info->fb.var.width       = -1;
  2160.   info->fb.var.accel_flags = 0;
  2162.   strcpy (info->fb.modename, info->fb.fix.id);
  2164.   info->fb.fbops          = &neofb_ops;
  2165.   info->fb.changevar      = NULL;
  2166.   info->fb.switch_con     = neofb_switch;
  2167.   info->fb.updatevar      = neofb_updatevar;
  2168.   info->fb.blank          = neofb_blank;
  2169.   info->fb.flags          = FBINFO_FLAG_DEFAULT;
  2170.   info->fb.disp           = (struct display *)(info + 1);
  2171.   info->fb.pseudo_palette = (void *)(info->fb.disp + 1);
  2173.   fb_alloc_cmap (&info->fb.cmap, NR_PALETTE, 0);
  2175.   return info;
  2176. }
  2178. static void __devinit neo_free_fb_info (struct neofb_info *info)
  2179. {
  2180.   if (info)
  2181.     {
  2182.       /*
  2183.        * Free the colourmap
  2184.        */
  2185.       fb_alloc_cmap (&info->fb.cmap, 0, 0);
  2187.       kfree (info);
  2188.     }
  2189. }
  2191. /* --------------------------------------------------------------------- */
  2193. static int __devinit neofb_probe (struct pci_dev* dev, const struct pci_device_id* id)
  2194. {
  2195.   struct neofb_info *info;
  2196.   u_int h_sync, v_sync;
  2197.   int err;
  2198.   int video_len;
  2200.   DBG("neofb_probe");
  2202.   err = pci_enable_device (dev);
  2203.   if (err)
  2204.     return err;
  2206.   err = -ENOMEM;
  2207.   info = neo_alloc_fb_info (dev, id);
  2208.   if (!info)
  2209.     goto failed;
  2211.   err = neo_map_mmio (info);
  2212.   if (err)
  2213.     goto failed;
  2215.   video_len = neo_init_hw (info);
  2216.   if (video_len < 0)
  2217.     {
  2218.       err = video_len;
  2219.       goto failed;
  2220.     }
  2222.   err = neo_map_video (info, video_len);
  2223.   if (err)
  2224.     goto failed;
  2226.   neofb_set_var (neofb_var, -1, &info->fb);
  2228.   /*
  2229.    * Calculate the hsync and vsync frequencies.  Note that
  2230.    * we split the 1e12 constant up so that we can preserve
  2231.    * the precision and fit the results into 32-bit registers.
  2232.    *  (1953125000 * 512 = 1e12)
  2233.    */
  2234.   h_sync = 1953125000 / info->fb.var.pixclock;
  2235.   h_sync = h_sync * 512 / (info->fb.var.xres + info->fb.var.left_margin +
  2236.    info->fb.var.right_margin + info->fb.var.hsync_len);
  2237.   v_sync = h_sync / (info->fb.var.yres + info->fb.var.upper_margin +
  2238.      info->fb.var.lower_margin + info->fb.var.vsync_len);
  2240.   printk(KERN_INFO "neofb v" NEOFB_VERSION ": %dkB VRAM, using %dx%d, %d.%03dkHz, %dHzn",
  2241.  info->fb.fix.smem_len >> 10,
  2242.  info->fb.var.xres, info->fb.var.yres,
  2243.  h_sync / 1000, h_sync % 1000, v_sync);
  2246.   err = register_framebuffer (&info->fb);
  2247.   if (err < 0)
  2248.     goto failed;
  2250.   printk (KERN_INFO "fb%d: %s frame buffer devicen",
  2251.   GET_FB_IDX(info->fb.node), info->fb.modename);
  2253.   /*
  2254.    * Our driver data
  2255.    */
  2256.   dev->driver_data = info;
  2258.   return 0;
  2260. failed:
  2261.   neo_unmap_video (info);
  2262.   neo_unmap_mmio (info);
  2263.   neo_free_fb_info (info);
  2265.   return err;
  2266. }
  2268. static void __devexit neofb_remove (struct pci_dev *dev)
  2269. {
  2270.   struct neofb_info *info = (struct neofb_info *)dev->driver_data;
  2272.   DBG("neofb_remove");
  2274.   if (info)
  2275.     {
  2276.       /*
  2277.        * If unregister_framebuffer fails, then
  2278.        * we will be leaving hooks that could cause
  2279.        * oopsen laying around.
  2280.        */
  2281.       if (unregister_framebuffer (&info->fb))
  2282. printk (KERN_WARNING "neofb: danger danger!  Oopsen imminent!n");
  2284.       neo_unmap_video (info);
  2285.       neo_unmap_mmio (info);
  2286.       neo_free_fb_info (info);
  2288.       /*
  2289.        * Ensure that the driver data is no longer
  2290.        * valid.
  2291.        */
  2292.       dev->driver_data = NULL;
  2293.     }
  2294. }
  2296. static struct pci_device_id neofb_devices[] __devinitdata = {
  2297.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2070,
  2298.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2070},
  2300.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2090,
  2301.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2090},
  2303.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2093,
  2304.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2093},
  2306.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2097,
  2307.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2097},
  2309.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2160,
  2310.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2160},
  2312.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2200,
  2313.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2200},
  2315.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2230,
  2316.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2230},
  2318.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2360,
  2319.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2360},
  2321.   {PCI_VENDOR_ID_NEOMAGIC, PCI_CHIP_NM2380,
  2322.    PCI_ANY_ID, PCI_ANY_ID, 0, 0, FB_ACCEL_NEOMAGIC_NM2380},
  2324.   {0, 0, 0, 0, 0, 0, 0}
  2325. };
  2327. MODULE_DEVICE_TABLE(pci, neofb_devices);
  2329. static struct pci_driver neofb_driver = {
  2330.   name:      "neofb",
  2331.   id_table:  neofb_devices,
  2332.   probe:     neofb_probe,
  2333.   remove:    __devexit_p(neofb_remove)
  2334. };
  2336. /* **************************** init-time only **************************** */
  2338. static void __init neo_init (void)
  2339. {
  2340.   DBG("neo_init");
  2341.   pci_register_driver (&neofb_driver);
  2342. }
  2344. /* **************************** exit-time only **************************** */
  2346. static void __exit neo_done (void)
  2347. {
  2348.   DBG("neo_done");
  2349.   pci_unregister_driver (&neofb_driver);
  2350. }
  2353. #ifndef MODULE
  2355. /* ************************* init in-kernel code ************************** */
  2357. int __init neofb_setup (char *options)
  2358. {
  2359.   char *this_opt;
  2361.   DBG("neofb_setup");
  2363.   if (!options || !*options)
  2364.     return 0;
  2366.   for (this_opt=strtok(options,","); this_opt; this_opt=strtok(NULL,","))
  2367.     {
  2368.       if (!*this_opt) continue;
  2370.       if (!strncmp(this_opt, "disabled", 8))
  2371. disabled = 1;
  2372.       if (!strncmp(this_opt, "internal", 8))
  2373. internal = 1;
  2374.       if (!strncmp(this_opt, "external", 8))
  2375. external = 1;
  2376.       if (!strncmp(this_opt, "nostretch", 9))
  2377. nostretch = 1;
  2378.       if (!strncmp(this_opt, "nopciburst", 10))
  2379. nopciburst = 1;
  2380.     }
  2382.   return 0;
  2383. }
  2385. static int __initdata initialized = 0;
  2387. int __init neofb_init(void)
  2388. {
  2389.   DBG("neofb_init");
  2391.   if (disabled)
  2392.     return -ENXIO;
  2394.   if (!initialized)
  2395.     {
  2396.       initialized = 1;
  2397.       neo_init();
  2398.     }
  2400.   /* never return failure, user can hotplug card later... */
  2401.   return 0;
  2402. }
  2404. #else
  2406. /* *************************** init module code **************************** */
  2408. int __init init_module(void)
  2409. {
  2410.   DBG("init_module");
  2412.   if (disabled)
  2413.     return -ENXIO;
  2415.   neo_init();
  2417.   /* never return failure; user can hotplug card later... */
  2418.   return 0;
  2419. }
  2421. #endif /* MODULE */
  2423. module_exit(neo_done);