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

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

Linux/Unix编程

开发平台：

Unix_Linux

sstfb.c：源码内容
  1. /*
  2.  * linux/drivers/video/sstfb.c -- voodoo graphics frame buffer
  3.  *
  4.  *     Copyright (c) 2000-2002 Ghozlane Toumi <gtoumi@laposte.net>
  5.  *
  6.  *     Created 15 Jan 2000 by Ghozlane Toumi
  7.  *
  8.  * Contributions (and many thanks) :
  9.  *
  10.  * 03/2001 James Simmons   <jsimmons@linux-fbdev.org>
  11.  * 04/2001 Paul Mundt      <lethal@chaoticdreams.org>
  12.  * 05/2001 Urs Ganse       <ursg@uni.de>
  13.  *     (initial work on voodoo2 port, interlace)
  14.  * 09/2002 Helge Deller    <deller@gmx.de>
  15.  *     (enable driver on big-endian machines (hppa), ioctl fixes)
  16.  *
  17.  *
  18.  * $Id: sstfb.c,v 1.26.4.1 2001/08/29 01:30:37 ghoz Exp $
  19.  */
  21. /*
  22.  * The voodoo1 has the following memory mapped adress space:
  23.  * 0x000000 - 0x3fffff : registers              (4Mb)
  24.  * 0x400000 - 0x7fffff : linear frame buffer    (4Mb)
  25.  * 0x800000 - 0xffffff : texture memory         (8Mb)
  26.  */
  28. /*
  29.  * misc notes, TODOs, toASKs, and deep thoughts
  31. -TODO: at one time or another test that the mode is acceptable by the monitor
  32. -ASK: I can choose different ordering for the color bitfields (rgba argb ...)
  33.       wich one should i use ? is there any preferred one ? It seems ARGB is
  34.       the one ...
  35. -TODO: check the error paths . if something get wrong, the error doesn't seem
  36.       to be very well handled...if handled at all.. not good.
  37. -TODO: in  set_var check the validity of timings (hsync vsync)...
  38. -TODO: check and recheck the use of sst_wait_idle : we dont flush the fifo via
  39.        a nop command . so it's ok as long as the commands we pass don't go
  40.        through the fifo. warning: issuing a nop command seems to need pci_fifo
  41. -FIXME: in case of failure in the init sequence, be sure we return to a safe
  42.         state.
  43. -FIXME: 4MB boards have banked memory (FbiInit2 bits 1 & 20)
  44. -ASK: I stole "inverse" but seems it doesn't work... check what it realy does...
  45. -TODO: change struct sst_info fb_info from static to array/dynamic
  47.  *
  48.  */
  50. /*
  51.  * debug info
  52.  * SST_DEBUG : enable debugging
  53.  * SST_DEBUG_REG : debug registers
  54.  *   0 :  no debug
  55.  *   1 : dac calls, [un]set_bits, FbiInit
  56.  *   2 : insane debug level (log every register read/write)
  57.  * SST_DEBUG_FUNC : functions
  58.  *   0 : no debug
  59.  *   1 : function call / debug ioctl
  60.  *   2 : variables
  61.  *   3 : flood . you don't want to do that. trust me.
  62.  * SST_DEBUG_VAR : debug display/var structs
  63.  *   0 : no debug
  64.  *   1 : dumps display, fb_var
  65.  * SST_DEBUG_IOCTL : enable sstfb specific ioctls
  66.  *   0 : disable
  67.  *   1 : enable debug ioctls :
  68.  *    toggle vga (0x46db) : toggle vga_pass_through
  69.  *    fill fb    (0x46dc) : fills fb
  70.  *    dump var   (0x46dd) : logs display[0-5].var
  71.  *    test disp  (0x46de) : draws a test motif
  72.  */
  74. /* #define SST_DEBUG */
  75. #undef SST_DEBUG
  77. #define SST_DEBUG_REG   0
  78. #define SST_DEBUG_FUNC  0
  79. #define SST_DEBUG_VAR   0
  80. #define SST_DEBUG_IOCTL 1
  82. /* #define EN_24_32_BPP  *//* enable 24/32 bpp functions for testing only */
  83. #undef EN_24_32_BPP
  85. /*
  86.   Default video mode .
  87.   0 800x600@60  took from glide
  88.   1 640x480@75  took from glide
  89.   2 1024x768@76 std fb.mode
  90.   3 640x480@60  glide default */
  91. #define DEFAULT_MODE 1
  92. /*
  93.  * Includes
  94.  */
  96. #include <linux/string.h>
  97. #include <linux/config.h>
  98. #include <linux/kernel.h>
  99. #include <linux/module.h>
  100. #include <linux/tty.h>
  101. #include <linux/fb.h>
  102. #include <linux/pci.h>
  103. #include <linux/delay.h>
  104. #include <linux/init.h>
  105. #include <linux/version.h>
  106. #include <linux/slab.h>
  108. #include <asm/io.h>
  109. #include <asm/ioctl.h>
  110. #include <asm/uaccess.h>
  112. #include <video/fbcon.h>
  113. #include <video/fbcon-cfb16.h>
  114. #ifdef  EN_24_32_BPP
  115. #  include <video/fbcon-cfb24.h>
  116. #  include <video/fbcon-cfb32.h>
  117. #endif
  119. #include "sstfb.h"
  121. /* void __Dump_regs(struct sstfb_info *);
  122. #define Dump_regs __Dump_regs(sst_info) */
  124. /********/
  127. /* initialized by setup */
  128. static int inverse; /* =0 */ /* invert colormap */
  129. static int vgapass; /* =0 */ /* enable Vga passthrough cable */
  130. static int mem;     /* =0 */ /* mem size in Mb , 0 = autodetect */
  131. static int clipping = 1; /* use clipping (slower, safer) */
  132. static int gfxclk;  /* =0 */ /* force FBI freq in Mhz . Dangerous */
  133. static int slowpci; /* =0 */ /* slow PCI settings */
  134. static int dev = -2; /* specify device (0..n) -2=all -1=none*/
  136. static char * mode_option ;
  139. /********/
  141. int sstfb_init(void);
  142. int sstfb_setup(char *options);
  143. static int __devinit sstfb_probe(struct pci_dev *pdev, const struct pci_device_id *id);
  144. static void __devexit sstfb_remove(struct pci_dev *pdev);
  147. /* Framebuffer API */
  148. static int sstfb_open(struct fb_info *info, int user);
  149. static int sstfb_release(struct fb_info *info, int user);
  150. static int sstfb_get_fix(struct fb_fix_screeninfo *fix,
  151.                          int con, struct fb_info *info);
  152. static int sstfb_get_var(struct fb_var_screeninfo *var,
  153.                          int con, struct fb_info *info);
  154. static int sstfb_set_var(struct fb_var_screeninfo *var,
  155.                          int con, struct fb_info *info);
  156. static int sstfb_get_cmap(struct fb_cmap *cmap, int kspc,
  157.                           int con, struct fb_info *info);
  158. static int sstfb_set_cmap(struct fb_cmap *cmap, int kspc,
  159.                           int con, struct fb_info *info);
  160. static int sstfb_pan_display(struct fb_var_screeninfo *var,
  161.                              int con, struct fb_info *info);
  162. static int sstfb_ioctl(struct inode *inode, struct file *file,
  163.                        u_int cmd, u_long arg, int con,
  164.                        struct fb_info *info);
  166. /* Interface to the low level console driver */
  167. static int sstfbcon_switch(int con, struct fb_info *info);
  168. static int sstfbcon_updatevar(int con, struct fb_info *info);
  169. static void sstfbcon_blank(int blank, struct fb_info *info);
  171. /* Internal routines */
  172. static void sstfb_install_cmap(int con, struct fb_info *info);
  173. static int sstfb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
  174.                            u_int *transp, struct fb_info *info);
  175. static int sstfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  176.                            u_int transp, struct fb_info *info);
  178. static int sstfb_set_par(const struct sstfb_par *par,
  179.                           struct sstfb_info *sst_info);
  180. static int sstfb_decode_var (const struct fb_var_screeninfo *var,
  181.                              struct sstfb_par *par,
  182.                              const struct sstfb_info *sst_info);
  183. static int sstfb_encode_var (struct fb_var_screeninfo *var,
  184.                              const struct sstfb_par *par,
  185.                              const struct sstfb_info *sst_info);
  187. static void sstfb_test16(struct sstfb_info *sst_info);
  189. #ifdef EN_24_32_BPP
  190. static void sstfb_test32(struct sstfb_info *sst_info);
  191. #endif
  193. /* Low level routines */
  194. static int sst_get_memsize(struct sstfb_info *sst_info, u_long *memsize);
  195. static int __sst_wait_idle(u_long vbase);
  196. #define sst_wait_idle()  __sst_wait_idle(sst_info->mmio.vbase)
  197. static int sst_detect_dactype(struct sstfb_info *sst_info);
  198. static int sst_detect_att(struct sstfb_info *sst_info);
  199. static int sst_detect_ti(struct sstfb_info *sst_info);
  200. static int sst_detect_ics(struct sstfb_info *sst_info);
  201. static int sst_calc_pll(const int freq, int *freq_out, struct pll_timing *t);
  202. static int sst_set_pll_att_ti(struct sstfb_info *sst_info, const struct pll_timing *t, const int clock);
  203. static int sst_set_pll_ics(struct sstfb_info *sst_info, const struct pll_timing *t, const int clock);
  204. static void sst_set_vidmod_att_ti(struct sstfb_info *sst_info, const int bpp);
  205. static void sst_set_vidmod_ics(struct sstfb_info *sst_info, const int bpp);
  206. static int sst_init(struct sstfb_info *sst_info);
  207. static void sst_shutdown(struct sstfb_info *sst_info);
  209. static struct fb_ops sstfb_ops = {
  210. owner : THIS_MODULE,
  211. fb_open: sstfb_open,
  212. fb_release: sstfb_release,
  213. fb_get_fix: sstfb_get_fix,
  214. fb_get_var: sstfb_get_var,
  215. fb_set_var: sstfb_set_var,
  216. fb_get_cmap: sstfb_get_cmap,
  217. fb_set_cmap: sstfb_set_cmap,
  218. fb_pan_display: sstfb_pan_display,
  219. fb_ioctl: sstfb_ioctl,
  220. };
  222. enum {
  223. ID_VOODOO1 = 0,
  224. ID_VOODOO2 = 1,
  225. };
  227. #define IS_VOODOO2(info) ((info)->type == ID_VOODOO2 )
  229. static struct sst_spec voodoo_spec[] __devinitdata = {
  230. { name : "Voodoo Graphics",
  231. default_gfx_clock : 50000,
  232. max_gfxclk : 60, },
  233. { name : "Voodoo2",
  234. default_gfx_clock : 75000,
  235. max_gfxclk : 85, },
  236. };
  238. static struct pci_device_id sstfb_id_tbl[] __devinitdata = {
  239. { PCI_VENDOR_ID_3DFX, PCI_DEVICE_ID_3DFX_VOODOO,
  240.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, ID_VOODOO1 },
  241. { PCI_VENDOR_ID_3DFX, PCI_DEVICE_ID_3DFX_VOODOO2,
  242.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, ID_VOODOO2 },
  243. { 0 },
  244. };
  246. static struct pci_driver sstfb_driver = {
  247. name: "sstfb",
  248. id_table: sstfb_id_tbl,
  249. probe:          sstfb_probe,
  250. remove: __devexit_p(sstfb_remove),
  251. };
  253. static struct fb_var_screeninfo sstfb_default =
  254. #if ( DEFAULT_MODE == 0 )
  255.     { /* 800x600@60, 16 bpp .borowed from glide/sst1/include/sst1init.h */
  256.     800, 600, 800, 600, 0, 0, 16, 0,
  257.     {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0},
  258.     0, 0, -1, -1, 0,
  259.     25000, 86, 41, 23, 1, 127, 4,
  260.     0, FB_VMODE_NONINTERLACED };
  261. #endif
  262. #if ( DEFAULT_MODE == 1 )
  263.     {/* 640x480@75, 16 bpp .borowed from glide/sst1/include/sst1init.h */
  264.     640, 480, 640, 480, 0, 0, 16, 0,
  265.     {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0},
  266.     0, 0, -1, -1, 0,
  267.     31746, 118, 17, 16, 1, 63, 3,
  268.     0, FB_VMODE_NONINTERLACED };
  269. #endif
  270. #if ( DEFAULT_MODE == 2 )
  271.     { /* 1024x768@76 took from my /etc/fb.modes */
  272.     1024, 768, 1024, 768,0, 0, 16,0,
  273.     {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0},
  274.     0, 0, -1, -1, 0,
  275.     11764, 208, 8, 36, 16, 120, 3 ,
  276.     0, FB_VMODE_NONINTERLACED };
  277. #endif
  278. #if ( DEFAULT_MODE == 3 )
  279.     { /* 640x480@60 , 16bpp glide default ?*/
  280.     640, 480, 640, 480, 0, 0, 16, 0,
  281.     {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0},
  282.     0, 0, -1, -1, 0,
  283.     39721 ,  38, 26 ,  25 ,18  , 96 ,2,
  284.     0, FB_VMODE_NONINTERLACED };
  285. #endif
  287. static struct dac_switch dacs[] __devinitdata = {
  288. { name: "TI TVP3409",
  289. detect: sst_detect_ti,
  290. set_pll: sst_set_pll_att_ti,
  291. set_vidmod: sst_set_vidmod_att_ti },
  293. { name: "AT&T ATT20C409",
  294. detect: sst_detect_att,
  295. set_pll: sst_set_pll_att_ti,
  296. set_vidmod: sst_set_vidmod_att_ti },
  297. { name: "ICS ICS5342",
  298. detect: sst_detect_ics,
  299. set_pll: sst_set_pll_ics,
  300. set_vidmod: sst_set_vidmod_ics },
  301. };
  304. /*
  305.  *
  306.  *  Definitions
  307.  *
  308.  */
  310. #if (SST_DEBUG_VAR > 0)
  311. /* debug info / dump a fb_var_screeninfo */
  312. static void sst_dbg_print_var(struct fb_var_screeninfo *var) {
  313. dprintk(" {%d, %d, %d, %d, %d, %d, %d, %d,n",
  314.         var->xres, var->yres, var->xres_virtual, var->yres_virtual,
  315.         var->xoffset, var->yoffset,
  316.         var->bits_per_pixel, var->grayscale);
  317. dprintk(" {%d, %d, %d}, {%d, %d, %d}, {%d, %d, %d}, {%d, %d, %d},n",
  318.         var->red.offset, var->red.length, var->red.msb_right,
  319.         var->green.offset, var->green.length, var->green.msb_right,
  320.         var->blue.offset, var->blue.length, var->blue.msb_right,
  321.         var->transp.offset, var->transp.length,
  322.         var->transp.msb_right);
  323. dprintk(" %d, %d, %d, %d, %d,n",
  324.         var->nonstd, var->activate,
  325.         var->height, var->width, var->accel_flags);
  326. dprintk(" %d, %d, %d, %d, %d, %d, %d,n",
  327.         var->pixclock, var->left_margin, var->right_margin,
  328.         var->upper_margin, var->lower_margin,
  329.         var->hsync_len, var->vsync_len);
  330. dprintk(" %#x, %#x}n",var->sync, var->vmode);
  331. }
  332. #endif /* (SST_DEBUG_VAR > 0) */
  334. #if (SST_DEBUG_REG > 0)
  335. static void sst_dbg_print_read_reg (u32 reg, u32 val) {
  336. char * regname =NULL;
  337. switch (reg) {
  338. case FBIINIT0: regname="FbiInit0"; break;
  339. case FBIINIT1: regname="FbiInit1"; break;
  340. case FBIINIT2: regname="FbiInit2"; break;
  341. case FBIINIT3: regname="FbiInit3"; break;
  342. case FBIINIT4: regname="FbiInit4"; break;
  343. case FBIINIT5: regname="FbiInit5"; break;
  344. case FBIINIT6: regname="FbiInit6"; break;
  345. }
  346. if (regname == NULL)
  347. r_ddprintk("sst_read(%#x): %#xn", reg, val);
  348. else
  349. r_dprintk(" sst_read(%s): %#xn", regname, val);
  350. }
  352. static void sst_dbg_print_write_reg (u32 reg, u32 val) {
  353. char * regname = NULL;
  355. switch (reg) {
  356. case FBIINIT0: regname="FbiInit0"; break;
  357. case FBIINIT1: regname="FbiInit1"; break;
  358. case FBIINIT2: regname="FbiInit2"; break;
  359. case FBIINIT3: regname="FbiInit3"; break;
  360. case FBIINIT4: regname="FbiInit4"; break;
  361. case FBIINIT5: regname="FbiInit5"; break;
  362. case FBIINIT6: regname="FbiInit6"; break;
  363. }
  364. if (regname == NULL)
  365. r_ddprintk("sst_write(%#x, %#x)n", reg, val);
  366. else
  367. r_dprintk(" sst_write(%s, %#x)n", regname, val);
  368. }
  369. #else /*  (SST_DEBUG_REG > 0) */
  370. #  define sst_dbg_print_read_reg(reg, val) do {}while(0)
  371. #  define sst_dbg_print_write_reg(reg, val) do {}while(0)
  372. #endif /*  (SST_DEBUG_REG > 0) */
  374. /* register access */
  375. #define sst_read(reg) __sst_read(sst_info->mmio.vbase, reg)
  376. #define sst_write(reg,val) __sst_write(sst_info->mmio.vbase, reg, val)
  377. #define sst_set_bits(reg,val) __sst_set_bits(sst_info->mmio.vbase, reg, val)
  378. #define sst_unset_bits(reg,val) __sst_unset_bits(sst_info->mmio.vbase, reg, val)
  379. #define sst_dac_read(reg) __sst_dac_read(sst_info->mmio.vbase, reg)
  380. #define sst_dac_write(reg,val) __sst_dac_write(sst_info->mmio.vbase, reg, val)
  381. #define dac_i_read(reg) __dac_i_read(sst_info->mmio.vbase, reg)
  382. #define dac_i_write(reg,val) __dac_i_write(sst_info->mmio.vbase, reg, val)
  384. static inline u32 __sst_read(u_long vbase, u32 reg)
  385. {
  386. u32 ret;
  388. ret = readl(vbase + reg);
  389. sst_dbg_print_read_reg(reg, ret);
  390. return ret;
  391. }
  393. static inline void __sst_write(u_long vbase, u32 reg, u32 val)
  394. {
  395. sst_dbg_print_write_reg(reg, val);
  396. writel(val, vbase + reg);
  397. }
  399. static inline void __sst_set_bits(u_long vbase, u32 reg, u32 val)
  400. {
  401. r_dprintk("sst_set_bits(%#x, %#x)n", reg, val);
  402. __sst_write(vbase, reg, __sst_read(vbase, reg) | val);
  403. }
  405. static inline void __sst_unset_bits(u_long vbase, u32 reg, u32 val)
  406. {
  407. r_dprintk("sst_unset_bits(%#x, %#x)n", reg, val);
  408. __sst_write(vbase, reg, __sst_read(vbase, reg) & ~val);
  409. }
  411. /* dac access */
  412. /* dac_read should be remaped to FbiInit2 (via the pci reg init_enable) */
  413. static u8 __sst_dac_read(u_long vbase, u8 reg)
  414. {
  415. u8 ret;
  417. #ifdef SST_DEBUG
  418. if ((reg & 0x07) != reg) {
  419. dprintk("bug line %d: register adress '%d' is too highn",
  420.          __LINE__,reg);
  421. }
  422. #endif
  423. reg &= 0x07;
  424. __sst_write(vbase, DAC_DATA, ((u32)reg << 8) | DAC_READ_CMD );
  425. __sst_wait_idle(vbase);
  426. /*udelay(10);*/
  427. ret=(__sst_read(vbase, DAC_READ) & 0xff);
  428. r_dprintk("sst_dac_read(%#x): %#xn", reg, ret);
  429. return (u8)ret;
  430. }
  432. static void __sst_dac_write(u_long vbase, u8 reg, u8 val)
  433. {
  434. r_dprintk("sst_dac_write(%#x, %#x)n", reg, val);
  435. #ifdef SST_DEBUG
  436. if ((reg & 0x07) != reg)
  437. dprintk("bug line %d: register adress '%d' is too highn",
  438.          __LINE__,reg);
  439. #endif
  440. reg &= 0x07;
  441. __sst_write(vbase, DAC_DATA,(((u32)reg << 8)) | (u32)val);
  442. }
  444. /* indexed access to ti/att dacs */
  445. static u32 __dac_i_read(u_long vbase, u8 reg)
  446. {
  447. u32 ret;
  449. __sst_dac_write(vbase, DACREG_ADDR_I, reg);
  450. ret = __sst_dac_read(vbase, DACREG_DATA_I);
  451. r_dprintk("sst_dac_read_i(%#x): %#xn", reg, ret);
  452. return ret;
  453. }
  454. static void __dac_i_write(u_long vbase, u8 reg,u8 val)
  455. {
  456. r_dprintk("sst_dac_write_i(%#x, %#x)n", reg, val);
  457. __sst_dac_write(vbase, DACREG_ADDR_I, reg);
  458. __sst_dac_write(vbase, DACREG_DATA_I, val);
  459. }
  461. /*
  462.  *
  463.  *  Internal routines
  464.  *
  465.  */
  467. static void sstfb_install_cmap(int con, struct fb_info *info)
  468. {
  469. #define sst_info ((struct sstfb_info *) info)
  470. f_dprintk("sstfb_install_cmap(con: %d)n",con);
  471. f_ddprintk("currcon: %dn", sst_info->currcon);
  472. if (con != sst_info->currcon)
  473. return;
  474. if (fb_display[con].cmap.len)
  475. fb_set_cmap(&fb_display[con].cmap, 1, sstfb_setcolreg, info);
  476. else
  477. fb_set_cmap(
  478. fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
  479. 1, sstfb_setcolreg, info);
  480. #undef sst_info
  481. }
  483. static int sstfb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
  484.                            u_int *transp, struct fb_info *info)
  485. {
  486. #define sst_info ((struct sstfb_info *) info)
  487. f_dddprintk("sstfb_getcolregn");
  488. if (regno >= 16) return 1;
  490. *red    = sst_info->palette[regno].red;
  491. *green  = sst_info->palette[regno].green;
  492. *blue   = sst_info->palette[regno].blue;
  493. *transp = sst_info->palette[regno].transp;
  494. f_dddprintk("%-2d rvba: %#x, %#x, %#x, %#xn",
  495.             regno,*red, *green, *blue, *transp);
  496. return 0;
  497. #undef sst_info
  498. }
  500. static int sstfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  501.                            u_int transp, struct fb_info *info)
  502. {
  503. #define sst_info ((struct sstfb_info *) info)
  504. u32 col;
  505. struct display * disp;
  507. f_dddprintk("sstfb_setcolregn");
  508. f_dddprintk("%-2d rvba: %#x, %#x, %#x, %#xn",
  509.             regno, red, green, blue, transp);
  510. if (regno >= 16) return 1;
  512. sst_info->palette[regno].red   = red;
  513. sst_info->palette[regno].green = green;
  514. sst_info->palette[regno].blue  = blue;
  515. sst_info->palette[regno].transp= transp;
  517. disp=&sst_info->disp;
  518. red    >>= (16 - disp->var.red.length);
  519. green  >>= (16 - disp->var.green.length);
  520. blue   >>= (16 - disp->var.blue.length);
  521. transp >>= (16 - disp->var.transp.length);
  522. col = (red << disp->var.red.offset)
  523.     | (green << disp->var.green.offset)
  524.     | (blue  << disp->var.blue.offset)
  525.     | (transp << disp->var.transp.offset);
  527. switch(disp->var.bits_per_pixel) {
  528. #ifdef FBCON_HAS_CFB16
  529. case 16:
  530. sst_info->fbcon_cmap.cfb16[regno]=(u16)col;
  531. break;
  532. #endif
  533. #ifdef EN_24_32_BPP
  534. #ifdef FBCON_HAS_CFB24
  535. case 24:
  536. sst_info->fbcon_cmap.cfb32[regno]=col;
  537. break;
  538. #endif
  539. #ifdef FBCON_HAS_CFB32
  540. case 32:
  541. sst_info->fbcon_cmap.cfb32[regno]=col;
  542. break;
  543. #endif
  544. #endif
  545. default:
  546. eprintk("bug line %d: bad depth '%u'n",__LINE__,
  547. disp->var.bits_per_pixel);
  548. break;
  549. }
  550. f_dddprintk("bpp: %d . encoded color: %#xn",
  551.             disp->var.bits_per_pixel, col);
  552. return 0;
  553. #undef sst_info
  554. }
  556. /* set par according to var ( checks var ) */
  557. static int sstfb_decode_var (const struct fb_var_screeninfo *var,
  558.                              struct sstfb_par *par,
  559.                              const struct sstfb_info *sst_info)
  560. {
  561. int real_length;
  563. f_dprintk("sstfb_decode_varn");
  564. /* Check var validity */
  565. par->valid=0;
  567. memset(par, 0, sizeof(par));
  568. par->xDim       = var->xres;
  569. par->hSyncOn    = var->hsync_len;
  570. par->hSyncOff   = var->xres + var->right_margin + var->left_margin;
  571. par->hBackPorch = var->left_margin;
  572. par->yDim       = var->yres;
  573. par->vSyncOn    = var->vsync_len;
  574. par->vSyncOff   = var->yres + var->lower_margin + var->upper_margin;
  575. par->vBackPorch = var->upper_margin;
  577. if(sst_calc_pll (PS2KHZ(var->pixclock), &par->freq, &par->pll)) {
  578. eprintk("Pixclock %d out of rangen", var->pixclock);
  579. return -EINVAL; //XXX
  580. }
  582. par->sync=var->sync & (FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT);
  583. par->vmode=var->vmode & (FB_VMODE_INTERLACED | FB_VMODE_DOUBLE);
  585. /* in laced mode, vBackPorch should be even. odd -> funky display */
  586. if (par->vmode & FB_VMODE_INTERLACED)
  587. par->vBackPorch += (par->vBackPorch % 2);
  588. if (par->vmode & FB_VMODE_DOUBLE) {
  589. par->vBackPorch <<= 1;
  590. par->yDim <<=1;
  591. par->vSyncOn <<=1;
  592. par->vSyncOff <<=1;
  593. }
  595. switch (var->bits_per_pixel) {
  596. case 0 ... 16 :
  597. par->bpp = 16;
  598. break;
  599. #ifdef EN_24_32_BPP
  600. case 17 ... 24 :
  601. par->bpp = 24;
  602. break;
  603. case 25 ... 32 :
  604. par->bpp = 32;
  605. break;
  606. #endif
  607. default :
  608. eprintk ("Unsupported bpp %dn", par->bpp);
  609. return -EINVAL;
  610. break;
  611. }
  613. if (IS_VOODOO2(sst_info)) {
  614. /* voodoo2 has 32 pixel wide tiles , BUT stange things
  615.  happen with odd number of tiles */
  616. par->tiles_in_X= (par->xDim + 63 ) / 64 * 2;
  617. } else {
  618. /* voodoo1 has 64 pixels wide tiles. */
  619. par->tiles_in_X= (par->xDim + 63 ) / 64;
  620. }
  622. /* validity tests */
  623. if((par->xDim <= 1) || (par->yDim <= 0 )
  624.    || (par->hSyncOn <= 1)
  625.    || (par->hSyncOff <= 1)
  626.    || (par->hBackPorch <= 2)
  627.    || (par->vSyncOn <= 0)
  628.    || (par->vSyncOff <= 0)
  629.    || (par->vBackPorch <= 0)
  630.    || (par->tiles_in_X <= 0)) {
  631. return -EINVAL;
  632. }
  633. if (IS_VOODOO2(sst_info)) {
  634. /* Voodoo 2 limits */
  635. if(((par->xDim-1) >= POW2(11)) || (par->yDim >= POW2(11))) {
  636. eprintk ("Unsupported resolution %dx%dn",
  637.          var->xres, var->yres);
  638. return -EINVAL;
  639. }
  640. if (((par->hSyncOn-1) >= POW2(9))
  641.    || ((par->hSyncOff-1) >= POW2(11))
  642.    || ((par->hBackPorch-2) >= POW2(9))
  643.    || (par->vSyncOn >= POW2(13))
  644.    || (par->vSyncOff >= POW2(13))
  645.    || (par->vBackPorch >= POW2(9))
  646.    || (par->tiles_in_X >= POW2(6))) {
  647. eprintk ("Unsupported Timingn");
  648. return -EINVAL;
  649. }
  650. } else {
  651. /* Voodoo limits */
  652. if (par->vmode) {
  653. eprintk("Interlace/Doublescan not supported %#xn",
  654. par->vmode);
  655. return -EINVAL;
  656. }
  657. if(((par->xDim-1) >= POW2(10)) || (par->yDim >= POW2(10))) {
  658. eprintk ("Unsupported resolution %dx%dn",
  659.          var->xres, var->yres);
  660. return -EINVAL;
  661. }
  662. if (((par->hSyncOn-1) >= POW2(8))
  663.    || ((par->hSyncOff-1) >= POW2(10))
  664.    || ((par->hBackPorch-2) >= POW2(8))
  665.    || (par->vSyncOn >= POW2(12))
  666.    || (par->vSyncOff >= POW2(12))
  667.    || (par->vBackPorch >= POW2(8))
  668.    || (par->tiles_in_X >= POW2(4))) {
  669. eprintk ("Unsupported Timingsn");
  670. return -EINVAL;
  671. }
  672. }
  674. /* it seems that the fbi uses tiles of 64x16 pixels to "map" the mem*/
  675. /* FIXME: i don't like this... looks wrong*/
  676. real_length = par->tiles_in_X  * (IS_VOODOO2(sst_info) ? 32 : 64 )
  677.               * ((par->bpp == 16) ? 2 : 4);
  679. if ((real_length * var->yres) > sst_info->video.len) {
  680. eprintk ("Not enough video memoryn");
  681. return -ENOMEM;
  682. }
  683. par->valid=1;
  684. return 0;
  685. }
  687. /* sets var according to par (basicaly, sets sane values) */
  688. static int sstfb_encode_var (struct fb_var_screeninfo *var,
  689.                              const struct sstfb_par *par,
  690.                              const struct sstfb_info *sst_info)
  691. {
  692. memset(var,0,sizeof(struct fb_var_screeninfo));
  694. var->xres           = par->xDim;
  695. var->yres           = par->yDim;
  696. var->xres_virtual   = par->xDim;
  697. var->yres_virtual   = par->yDim;
  698. var->bits_per_pixel = par->bpp;
  699. /* {x|y}offset = 0 ; sync=0 */
  700. var->height         = -1;
  701. var->width          = -1;
  702. var->pixclock       = KHZ2PS(par->freq);
  703. var->left_margin    = par->hBackPorch;
  704. var->right_margin   = par->hSyncOff - par->xDim - par->hBackPorch;
  705. var->upper_margin   = par->vBackPorch;
  706. var->lower_margin   = par->vSyncOff - par->yDim - par->vBackPorch;
  707. var->hsync_len      = par->hSyncOn;
  708. var->vsync_len      = par->vSyncOn;
  709. var->sync           = par->sync;
  710. var->vmode          = par->vmode;
  711. if (var->vmode & FB_VMODE_DOUBLE) {
  712. var->yres           >>=1;
  713. var->yres_virtual   >>=1;
  714. var->vsync_len      >>=1;
  715. var->upper_margin   >>=1;
  716. var->lower_margin   >>=1;
  717. }
  719. /*
  720.  * correct the color bit fields
  721.  */
  722. /* var->{red|green|blue}.msb_right    = 0; */
  724. switch (par->bpp) {
  725. case 16: /* RGB 565  LfbMode 0 */
  726. var->red.length    = 5;
  727. var->green.length  = 6;
  728. var->blue.length   = 5;
  729. var->transp.length = 0;
  731. var->red.offset    = 11;
  732. var->green.offset  = 5;
  733. var->blue.offset   = 0;
  734. var->transp.offset = 0;
  735. break;
  736. #ifdef EN_24_32_BPP
  737. case 24: /* RGB 888 LfbMode 4 */
  738. case 32: /* ARGB 8888 LfbMode 5 */
  739. var->red.length    = 8;
  740. var->green.length  = 8;
  741. var->blue.length   = 8;
  742. var->transp.length = 0;
  744. var->red.offset    = 16;
  745. var->green.offset  = 8;
  746. var->blue.offset   = 0;
  747. var->transp.offset = 0; /* in 24bpp we fake a 32 bpp mode */
  748. break;
  749. #endif
  750. default:
  751. eprintk ("bug line %d: bad depth '%u'n", __LINE__, par->bpp);
  752. break;
  753. }
  754. return 0;
  755. }
  757. /*
  758.  * Frame buffer API
  759.  */
  761. static int sstfb_open(struct fb_info *info, int user)
  762. {
  763. f_dprintk("sstfb_open(user: %d)n",user);
  764. return 0;
  765. }
  767. static int sstfb_release(struct fb_info *info, int user)
  768. {
  769. f_dprintk("sstfb_release(user: %d)n",user);
  770. return 0;
  771. }
  773. static int sstfb_get_fix(struct fb_fix_screeninfo *fix,
  774.                          int con, struct fb_info *info)
  775. {
  776. #define sst_info ((struct sstfb_info *) info)
  778.    struct fb_var_screeninfo *var;
  779.   struct fb_var_screeninfo var2;
  781. f_dprintk("sstfb_get_fix(con: %d)n",con);
  782. memset(fix, 0, sizeof(struct fb_fix_screeninfo));
  784. if (con == -1)
  785. {
  786. sstfb_encode_var(&var2, &sst_info->current_par, sst_info);
  787. var = &var2;
  788. }
  789. else
  790. var = &fb_display[con].var;
  792. strcpy(fix->id, sst_info->info.modename);
  793. /* lfb phys address = membase + 4Mb */
  794. fix->smem_start  = sst_info->video.base;
  795. fix->smem_len    = sst_info->video.len;
  797. fix->type        = FB_TYPE_PACKED_PIXELS;
  798. fix->visual      = FB_VISUAL_TRUECOLOR;
  799. fix->accel       = FB_ACCEL_NONE;
  800. /*
  801.  *   According to the specs, the linelength must be of 1024 *pixels*.
  802.  * and the 24bpp mode is in fact a 32 bpp mode.
  803.  */
  804. fix->line_length = (var->bits_per_pixel == 16) ? 2048 : 4096 ;
  805. return 0;
  806. #undef sst_info
  807. }
  809. static int sstfb_get_var(struct fb_var_screeninfo *var,
  810.                          int con, struct fb_info *info)
  811. {
  812. #define sst_info ((struct sstfb_info *) info)
  813. f_dprintk("sstfb_get_var(con: %d)n",con);
  814. if (con == -1)
  815. sstfb_encode_var(var, &sst_info->current_par, sst_info);
  816. else
  817. *var = fb_display[con].var;
  818. print_var(var, "var");
  819. return 0;
  820. #undef sst_info
  821.  }
  823. static int sstfb_set_var(struct fb_var_screeninfo *var,
  824.                          int con, struct fb_info *info)
  825. {
  826. #define sst_info ((struct sstfb_info *) info)
  828. struct sstfb_par par;
  829. struct display *display;
  830. int err;
  831. int old_bpp,old_xres,old_yres;
  833. f_dprintk("sstfb_set_var(con: %d)n",con);
  834. f_ddprintk("xres yres vxres vyres bpp activaten");
  835. f_ddprintk("%-4d %-4d %-5d %-5d %-3d %#-8xn",
  836.  var->xres,var->yres,var->xres_virtual,var->yres_virtual,
  837.  var->bits_per_pixel,var->activate);
  838. if (con < 0)
  839. display = &sst_info->disp;
  840. else
  841. display = &fb_display[con];
  843. if ((err = sstfb_decode_var(var, &par, sst_info)))
  844. return err;
  845. sstfb_encode_var (var, &par, sst_info);
  847. switch (var->activate & FB_ACTIVATE_MASK) {
  848. case FB_ACTIVATE_TEST:
  849. return 0;
  850. case FB_ACTIVATE_NXTOPEN:
  851. case FB_ACTIVATE_NOW:
  852. break;
  853. default:
  854. return -EINVAL;
  855. }
  856. old_xres = display->var.xres;
  857. old_yres = display->var.yres;
  858. old_bpp  = display->var.bits_per_pixel;
  859. display->var = *var;
  861. if ((old_xres != var->xres) || (old_yres != var->yres)
  862.     || (old_bpp != var->bits_per_pixel)) {
  863. /* 2-3  lignes redondantes avec get_fix */
  864. display->screen_base = (char *) sst_info->video.vbase;
  865. display->visual = FB_VISUAL_TRUECOLOR;
  866. display->type = FB_TYPE_PACKED_PIXELS;
  867. display->type_aux = 0;
  868. display->ypanstep = 0;
  869. display->ywrapstep = 0;
  870. display->line_length = (var->bits_per_pixel==16) ? 2048 : 4096;
  871. display->inverse = 0;
  872. switch (var->bits_per_pixel) {
  873. #ifdef FBCON_HAS_CFB16
  874. case 16:
  875. display->dispsw = &fbcon_cfb16;
  876. display->dispsw_data = sst_info->fbcon_cmap.cfb16;
  877. break;
  878. #endif
  879. #ifdef EN_24_32_BPP
  880. #if defined (FBCON_HAS_CFB24) || defined (FBCON_HAS_CFB32 )
  881. case 24: /*24bpp non packed <=> 32 bpp */
  882. case 32:
  883. display->dispsw = &fbcon_cfb32;
  884. display->dispsw_data = sst_info->fbcon_cmap.cfb32;
  885. break;
  886. #endif
  887. #endif
  888. default:
  889. display->dispsw = &fbcon_dummy;
  890. break;
  891. }
  892. display->scrollmode = SCROLL_YREDRAW;
  893. if (sst_info->info.changevar) {
  894. v_dprintk("fb_info.changevar(con: %d)n", con);
  895. (*sst_info->info.changevar)(con);
  896. v_dprintk("fb_info.changevar: done n");
  897. } else {
  898. v_dprintk("fb_info.changevar() == NULL . n");
  899. }
  900. }
  902. if ((con == -1) || (con==sst_info->currcon)) {
  903. sstfb_set_par (&par, sst_info);
  904. }
  905. print_var(var, "var");
  906. print_var(&display->var, "&display->var");
  908. if (old_bpp != var->bits_per_pixel) {
  909.     if ((err = fb_alloc_cmap(&display->cmap, 0, 0)))
  910. return err;
  911.     sstfb_install_cmap(con, info);
  912. }
  914. return 0;
  915. #undef sst_info
  916. }
  919. static int sstfb_set_cmap(struct fb_cmap *cmap, int kspc,
  920.                           int con, struct fb_info *info)
  921. {
  922. #define sst_info ((struct sstfb_info *) info)
  923. struct display *d = (con<0) ? info->disp : fb_display + con;
  925. f_dprintk("sstfb_set_cmapn");
  926. f_ddprintk("con: %d, currcon: %d, d->cmap.len %dn",
  927.  con, sst_info->currcon, d->cmap.len);
  929. if (d->cmap.len != 16 ) { /* or test if cmap.len == 0 ? */
  930. int err;
  931. err = fb_alloc_cmap(&d->cmap, 16, 0); /* cmap size=16 */
  932. if (err) return err;
  933. }
  934. if (con == sst_info->currcon) {
  935. return fb_set_cmap(cmap, kspc, sstfb_setcolreg, info);
  936. } else {
  937. fb_copy_cmap(cmap, &d->cmap, kspc ? 0 : 1);
  938. }
  939. return 0;
  940. #undef sst_info
  941. }
  943. static int sstfb_get_cmap(struct fb_cmap *cmap, int kspc,
  944.                           int con, struct fb_info *info)
  945. {
  946. #define sst_info ((struct sstfb_info *) info)
  947. f_dprintk("sstfb_get_cmapn");
  948. f_ddprintk("con %d, curcon %d, cmap.len %dn",
  949.  con, sst_info->currcon, fb_display[con].cmap.len);
  951. /* FIXME: check if con = -1 ? cf sstfb_set_cmap...  */
  952. if (con == sst_info->currcon)
  953. return fb_get_cmap(cmap, kspc, sstfb_getcolreg, info);
  954. else if (fb_display[con].cmap.len)
  955. fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
  956. else
  957. fb_copy_cmap(
  958. fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
  959. cmap, kspc ? 0 : 2);
  960. return 0;
  961. #undef sst_info
  962. }
  964. /* TODO */
  965. static int sstfb_pan_display(struct fb_var_screeninfo *var,
  966.                              int con, struct fb_info *info)
  967. {
  968. f_dprintk("sstfb_pan_displayn");
  969. return -EINVAL;
  970. }
  972. static int sstfb_ioctl(struct inode *inode, struct file *file,
  973.                        u_int cmd, u_long arg, int con,
  974.                        struct fb_info *info)
  975. {
  976. #define sst_info ((struct sstfb_info *) info)
  977. #if (SST_DEBUG_IOCTL >0)
  978. int i;
  979. u_long p;
  980. u32 tmp, val;
  981. u32 fbiinit0;
  982. struct pci_dev * sst_dev = sst_info->dev;
  983. #endif
  985. f_dprintk("sstfb_ioctl(%x)n", cmd);
  986. #if (SST_DEBUG_IOCTL >0)
  987. switch (cmd) {
  988. #  if (SST_DEBUG_VAR >0)
  989. /* tmp ioctl : dumps fb_display[0-5] */
  990. case _IO('F', 0xdb): /* 0x46db */
  991. f_dprintk("dumping fb_display[0-5].varn");
  992. for (i = 0 ; i< 6 ; i++) {
  993. print_var(&fb_display[i].var, "var(%d)", i);
  994. }
  995. return 0;
  996. #  endif /* (SST_DEBUG_VAR >0) */
  997. /* fills the lfb up to *(u32*)arg */
  998. case _IOW('F', 0xdc, u32): /* 0x46dc */
  999. if (copy_from_user(&val, (void *) arg, sizeof(val)))
  1000. return -EFAULT;
  1001. if (val > 0x400000 )
  1002. val = 0x400000;
  1003. f_dprintk("filling %#x n", val);
  1004. for (p = 0 ; p < val; p+=2)
  1005. writew( p >> 6 , sst_info->video.vbase + p);
  1006. return 0;
  1007. /* change VGA pass_through */
  1008. case _IOW('F', 0xdd, u32): /* 0x46dd */
  1009. if (copy_from_user(&val, (void *) arg, sizeof(val)))
  1010. return -EFAULT;
  1011. f_dprintk("switch VGA pass-throughn");
  1012. pci_read_config_dword(sst_dev, PCI_INIT_ENABLE, &tmp);
  1013. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
  1014.        tmp | PCI_EN_INIT_WR );
  1015. fbiinit0 = sst_read (FBIINIT0);
  1016. if (val) {
  1017. sst_write(FBIINIT0, fbiinit0 & ~EN_VGA_PASSTHROUGH);
  1018. iprintk ( "Disabling VGA pass-throughn");
  1019. } else {
  1020. sst_write(FBIINIT0, fbiinit0 | EN_VGA_PASSTHROUGH);
  1021. iprintk ( "Enabling VGA pass-throughn");
  1022. }
  1023. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE, tmp);
  1024. return 0;
  1025. case _IO('F', 0xde): /* 0x46de */
  1026. f_dprintk("test color displayn");
  1027. f_ddprintk("currcon: %d, bpp %dn", sst_info->currcon,
  1028.   sst_info->current_par.bpp);
  1029. memset_io(sst_info->video.vbase, 0, sst_info->video.len);
  1030. switch (sst_info->current_par.bpp) {
  1031.         case 16:
  1032. sstfb_test16(sst_info);
  1033. break;
  1034. #  ifdef EN_24_32_BPP
  1035. case 24:
  1036. case 32:
  1037. sstfb_test32(sst_info);
  1038. break;
  1039. #  endif
  1040. default:
  1041. dprintk("bug line %d: bad depth '%u'n", __LINE__,
  1042.         sst_info->current_par.bpp);
  1043. }
  1044. return 0;
  1045. }
  1046. #endif /* (SST_DEBUG_IOCTL >0) */
  1047. return -EINVAL;
  1048. #undef sst_info
  1049. }
  1052. /*
  1053.  * Low level routines
  1054.  */
  1056. /* get lfb size */
  1058. static int __devinit sst_get_memsize(struct sstfb_info *sst_info, u_long *memsize)
  1059. {
  1060. u_long fbbase_virt = sst_info->video.vbase;
  1061. f_dprintk("sst_get_memsizen");
  1063. /* force memsize */
  1064. if ((mem >= 1 ) &&  (mem <= 4)) {
  1065. *memsize = (mem * 0x100000);
  1066. iprintk("supplied memsize: %#lxn", *memsize);
  1067. return 1;
  1068. }
  1070. writel (0xdeadbeef, fbbase_virt);
  1071. writel (0xdeadbeef, fbbase_virt+0x100000);
  1072. writel (0xdeadbeef, fbbase_virt+0x200000);
  1073. f_ddprintk("0Mb: %#x, 1Mb: %#x, 2Mb: %#xn",
  1074.            readl(fbbase_virt), readl(fbbase_virt + 0x100000),
  1075.            readl(fbbase_virt + 0x200000));
  1077. writel (0xabcdef01, fbbase_virt);
  1079. f_ddprintk("0Mb: %#x, 1Mb: %#x, 2Mb: %#xn",
  1080.            readl(fbbase_virt), readl(fbbase_virt + 0x100000),
  1081.            readl(fbbase_virt + 0x200000));
  1083. /* checks for 4mb lfb , then 2, then defaults to 1*/
  1084. if (readl(fbbase_virt + 0x200000) == 0xdeadbeef) {
  1085. *memsize = 0x400000;
  1086. } else if (readl(fbbase_virt + 0x100000) == 0xdeadbeef) {
  1087. *memsize = 0x200000;
  1088. } else {
  1089. *memsize = 0x100000;
  1090. }
  1091. f_ddprintk("detected memsize: %#lxn", *memsize);
  1092. return 1;
  1093. }
  1096. /*
  1097.  * wait for the fbi chip. ASK: what happens if the fbi is stuck ?
  1098.  *
  1099.  * the FBI is supposed to be ready if we receive 5 time
  1100.  * in a row a "idle" answer to our requests
  1101.  */
  1103. static int __sst_wait_idle(u_long vbase)
  1104. {
  1105. int count = 0;
  1107. f_ddprintk("sst_wait_idlen");
  1108. while(1) {
  1109. if (__sst_read(vbase, STATUS) & STATUS_FBI_BUSY) {
  1110. f_dddprintk("status: busyn");
  1111. /* FIXME basicaly, this is a busy wait. maybe not that good. oh well; this is a small loop after all ...*/
  1112. count = 0;
  1113. } else {
  1114. count++;
  1115. f_dddprintk("status: idle(%d)n", count);
  1116. }
  1117. if (count >= 5) return 1;
  1118. //XXX  do something to avoid hanging the machine if the voodoo is out
  1119. }
  1120. }
  1122. /*
  1123.  * detect dac type
  1124.  * prerequisite : write to FbiInitx enabled, video and fbi and pci fifo reset,
  1125.  * dram refresh disabled, FbiInit remaped.
  1126.  * TODO: mmh.. maybe i shoud put the "prerequisite" in the func ...
  1127.  */
  1128. static int __devinit sst_detect_dactype(struct sstfb_info * sst_info)
  1129. {
  1130. int ret=0,i;
  1131. f_dprintk("sst_detect_dactypen");
  1132. for (i=0; i< sizeof(dacs)/sizeof(dacs[0]) ; i++) {
  1133. ret = dacs[i].detect(sst_info);
  1134. if (ret) break;
  1135. }
  1136. if (!ret)
  1137. return 0;
  1138. f_dprintk("found %sn", dacs[i].name);
  1139. sst_info->dac_sw=dacs[i];
  1140. return 1;
  1141. }
  1143. /* fbi should be idle, and fifo emty and mem disabled */
  1144. /* supposed to detect AT&T ATT20C409 and Ti TVP3409 ramdacs */
  1146. static int __devinit sst_detect_att(struct sstfb_info * sst_info)
  1147. {
  1148. int i, mir, dir;
  1150. f_dprintk("sst_detect_attn");
  1151. for (i = 0; i<3; i++) {
  1152. sst_dac_write(DACREG_WMA, 0);  /* backdoor */
  1153. sst_dac_read(DACREG_RMR); /* read 4 times RMR */
  1154. sst_dac_read(DACREG_RMR);
  1155. sst_dac_read(DACREG_RMR);
  1156. sst_dac_read(DACREG_RMR);
  1157. /* the fifth time,  CR0 is read */
  1158. sst_dac_read(DACREG_RMR);
  1159. /* the 6th, manufacturer id register */
  1160. mir = sst_dac_read(DACREG_RMR);
  1161. /*the 7th, device ID register */
  1162. dir = sst_dac_read(DACREG_RMR);
  1163. f_ddprintk("mir: %#x, dir: %#xn", mir, dir);
  1164. if ((mir == DACREG_MIR_ATT ) && (dir == DACREG_DIR_ATT)) {
  1165. return 1;
  1166. }
  1167. }
  1168. return 0;
  1169. }
  1171. static int __devinit sst_detect_ti(struct sstfb_info * sst_info)
  1172. {
  1173. int i, mir, dir;
  1175. f_dprintk("sst_detect_tin");
  1176. for (i = 0; i<3; i++) {
  1177. sst_dac_write(DACREG_WMA, 0);  /* backdoor */
  1178. sst_dac_read(DACREG_RMR); /* read 4 times RMR */
  1179. sst_dac_read(DACREG_RMR);
  1180. sst_dac_read(DACREG_RMR);
  1181. sst_dac_read(DACREG_RMR);
  1182. /* the fifth time,  CR0 is read */
  1183. sst_dac_read(DACREG_RMR);
  1184. /* the 6th, manufacturer id register */
  1185. mir = sst_dac_read(DACREG_RMR);
  1186. /*the 7th, device ID register */
  1187. dir = sst_dac_read(DACREG_RMR);
  1188. f_ddprintk("mir: %#x, dir: %#xn", mir, dir);
  1189. if ((mir == DACREG_MIR_TI ) && (dir == DACREG_DIR_TI)) {
  1190. return 1;
  1191. }
  1192. }
  1193. return 0;
  1194. }
  1196. /*
  1197.  * try to detect ICS5342  ramdac
  1198.  * we get the 1st byte (M value) of preset f1,f7 and fB
  1199.  * why those 3 ? mmmh... for now, i'll do it the glide way...
  1200.  * and ask questions later. anyway, it seems that all the freq registers are
  1201.  * realy at their default state (cf specs) so i ask again, why those 3 regs ?
  1202.  * mmmmh.. it seems that's much more ugly than i thought. we use f0 and fA for
  1203.  * pll programming, so in fact, we *hope* that the f1, f7 & fB won't be
  1204.  * touched...
  1205.  * is it realy safe ? how can i reset this ramdac ? geee...
  1206.  */
  1207. static int __devinit sst_detect_ics(struct sstfb_info * sst_info)
  1208. {
  1209. int i;
  1210. int m_clk0_1, m_clk0_7, m_clk1_b;
  1211. int n_clk0_1, n_clk0_7, n_clk1_b;
  1212. f_dprintk("sst_detect_icsn");
  1213. for (i = 0; i<5; i++ ) {
  1214. sst_dac_write(DACREG_ICS_PLLRMA, 0x1); /* f1 */
  1215. m_clk0_1 = sst_dac_read(DACREG_ICS_PLLDATA);
  1216. n_clk0_1 = sst_dac_read(DACREG_ICS_PLLDATA);
  1217. sst_dac_write(DACREG_ICS_PLLRMA, 0x7); /* f7 */
  1218. m_clk0_7 = sst_dac_read(DACREG_ICS_PLLDATA);
  1219. n_clk0_7 = sst_dac_read(DACREG_ICS_PLLDATA);
  1220. sst_dac_write(DACREG_ICS_PLLRMA, 0xb); /* fB */
  1221. m_clk1_b= sst_dac_read(DACREG_ICS_PLLDATA);
  1222. n_clk1_b= sst_dac_read(DACREG_ICS_PLLDATA);
  1223. f_ddprintk("m_clk0_1: %#x, m_clk0_7: %#x, m_clk1_b: %#xn",
  1224. m_clk0_1, m_clk0_7, m_clk1_b);
  1225. f_ddprintk("n_clk0_1: %#x, n_clk0_7: %#x, n_clk1_b: %#xn",
  1226. n_clk0_1, n_clk0_7, n_clk1_b);
  1227. if ((   m_clk0_1 == DACREG_ICS_PLL_CLK0_1_INI)
  1228.     && (m_clk0_7 == DACREG_ICS_PLL_CLK0_7_INI)
  1229.     && (m_clk1_b == DACREG_ICS_PLL_CLK1_B_INI)) {
  1230. return 1;
  1231. }
  1232. }
  1233. return 0;
  1234. }
  1236. /* compute the m,n,p  , returns the real freq
  1237.  * (ics datasheet :  N <-> N1 , P <-> N2)
  1238.  *
  1239.  * Fout= Fref * (M+2)/( 2^P * (N+2))
  1240.  *  we try to get close to the asked freq
  1241.  *  with P as high, and M as low as possible
  1242.  * range:
  1243.  * ti/att : 0 <= M <= 255; 0 <= P <= 3; 0<= N <= 63
  1244.  * ics    : 1 <= M <= 127; 0 <= P <= 3; 1<= N <= 31
  1245.  * we'll use the lowest limitation, should be precise enouth
  1246.  */
  1247. static int sst_calc_pll(const int freq, int *freq_out, struct pll_timing *t)
  1248. {
  1249. int m, m2, n, p, best_err, fout;
  1250. int best_n=-1;
  1251. int best_m=-1;
  1253. f_dprintk("sst_calc_pll(%dKhz)n", freq);
  1254. best_err = freq;
  1255. p=3;
  1256. /* f * 2^P = vco should be less than VCOmax ~ 250 MHz for ics*/
  1257. while (((1 << p) * freq > VCO_MAX) && (p >= 0))
  1258. p--;
  1259. if (p == -1)
  1260. return -EINVAL;
  1261. for (n = 1; n < 32; n++) {
  1262. /* calc 2 * m so we can round it later*/
  1263. m2 = (2 * freq * (1 << p) * (n + 2) ) / DAC_FREF - 4 ;
  1265. m = (m2 % 2 ) ? m2/2+1 : m2/2 ;
  1266. if (m >= 128)
  1267. break;
  1268. fout = (DAC_FREF * (m + 2)) / ((1 << p) * (n + 2));
  1269. if ((ABS(fout - freq) < best_err) && (m > 0)) {
  1270. best_n = n;
  1271. best_m = m;
  1272. best_err = ABS(fout - freq);
  1273. /* we get the lowest m , allowing 0.5% error in freq*/
  1274. if (200*best_err < freq) break;
  1275. }
  1276. }
  1277. if (best_n == -1)  /* unlikely, but who knows ? */
  1278. return -EINVAL;
  1279. t->p=p;
  1280. t->n=best_n;
  1281. t->m=best_m;
  1282. *freq_out=(DAC_FREF * (t->m + 2)) / ((1 << t->p) * (t->n + 2));
  1283. f_ddprintk ("m: %d, n: %d, p: %d, F: %dKhzn",
  1284.   t->m, t->n, t->p, *freq_out);
  1285. return 0;
  1286. }
  1288. /*
  1289.  * gfx, video, pci fifo should be reset, dram refresh disabled
  1290.  * see detect_dac
  1291.  */
  1293. static int sst_set_pll_att_ti(struct sstfb_info * sst_info, const struct pll_timing *t, const int clock)
  1294. {
  1295. u8 cr0, cc;
  1296. f_dprintk("sst_set_pll_att_tin");
  1298. /* enable indexed mode */
  1300. sst_dac_write(DACREG_WMA, 0);  /* backdoor */
  1301. sst_dac_read(DACREG_RMR); /* 1 time:  RMR */
  1302. sst_dac_read(DACREG_RMR); /* 2 RMR */
  1303. sst_dac_read(DACREG_RMR); /* 3 //  */
  1304. sst_dac_read(DACREG_RMR); /* 4 //  */
  1305. cr0 = sst_dac_read(DACREG_RMR); /* 5 CR0 */
  1307. sst_dac_write(DACREG_WMA, 0);
  1308. sst_dac_read(DACREG_RMR);
  1309. sst_dac_read(DACREG_RMR);
  1310. sst_dac_read(DACREG_RMR);
  1311. sst_dac_read(DACREG_RMR);
  1312. sst_dac_write(DACREG_RMR, (cr0 & 0xf0)
  1313.               | DACREG_CR0_EN_INDEXED
  1314.               | DACREG_CR0_8BIT
  1315.               | DACREG_CR0_PWDOWN );
  1316. /* so, now we are in indexed mode . dunno if its common, but
  1317.    i find this way of doing things a little bit weird :p */
  1319. udelay(300);
  1320. cc = dac_i_read(DACREG_CC_I);
  1321. switch (clock) {
  1322. case VID_CLOCK:
  1323. dac_i_write(DACREG_AC0_I, t->m);
  1324. dac_i_write(DACREG_AC1_I, t->p << 6 | t->n);
  1325. dac_i_write(DACREG_CC_I,
  1326.             (cc & 0x0f) | DACREG_CC_CLKA | DACREG_CC_CLKA_C);
  1327. break;
  1328. case GFX_CLOCK:
  1329. dac_i_write(DACREG_BD0_I, t->m);
  1330. dac_i_write(DACREG_BD1_I, t->p << 6 | t->n);
  1331. dac_i_write(DACREG_CC_I,
  1332.             (cc & 0xf0) | DACREG_CC_CLKB | DACREG_CC_CLKB_D);
  1333. break;
  1334. default:
  1335. dprintk("bug line %d: wrong clock code '%d'n",
  1336.         __LINE__,clock);
  1337. return 0;
  1338. }
  1339. udelay(300);
  1341. /* power up the dac & return to "normal" non-indexed mode */
  1342. dac_i_write(DACREG_CR0_I,
  1343.             cr0 & ~DACREG_CR0_PWDOWN & ~DACREG_CR0_EN_INDEXED);
  1344. return 1;
  1345. }
  1347. static int sst_set_pll_ics(struct sstfb_info * sst_info, const struct pll_timing *t, const int clock)
  1348. {
  1349. u8 pll_ctrl;
  1351. f_dprintk("sst_set_pll_icsn");
  1353. sst_dac_write(DACREG_ICS_PLLRMA, DACREG_ICS_PLL_CTRL);
  1354. pll_ctrl = sst_dac_read(DACREG_ICS_PLLDATA);
  1355. switch(clock) {
  1356. case VID_CLOCK:
  1357. sst_dac_write(DACREG_ICS_PLLWMA, 0x0); /* CLK0, f0 */
  1358. sst_dac_write(DACREG_ICS_PLLDATA, t->m);
  1359. sst_dac_write(DACREG_ICS_PLLDATA, t->p << 5 | t->n);
  1360. /* selects freq f0 for clock 0 */
  1361. sst_dac_write(DACREG_ICS_PLLWMA, DACREG_ICS_PLL_CTRL);
  1362. sst_dac_write(DACREG_ICS_PLLDATA,
  1363.               (pll_ctrl & 0xd8)
  1364.               | DACREG_ICS_CLK0
  1365.               | DACREG_ICS_CLK0_0);
  1366. break;
  1367. case GFX_CLOCK :
  1368. sst_dac_write(DACREG_ICS_PLLWMA, 0xa); /* CLK1, fA */
  1369. sst_dac_write(DACREG_ICS_PLLDATA, t->m);
  1370. sst_dac_write(DACREG_ICS_PLLDATA, t->p << 5 | t->n);
  1371. /* selects freq fA for clock 1 */
  1372. sst_dac_write(DACREG_ICS_PLLWMA, DACREG_ICS_PLL_CTRL);
  1373. sst_dac_write(DACREG_ICS_PLLDATA,
  1374.               (pll_ctrl & 0xef) | DACREG_ICS_CLK1_A);
  1375. break;
  1376. default:
  1377. dprintk("bug line %d: wrong clock code '%d'n",
  1378.         __LINE__, clock);
  1379. return 0;
  1380. }
  1381. udelay(300);
  1382. return 1;
  1383. }
  1385. static int sstfb_set_par(const struct sstfb_par * par, struct sstfb_info * sst_info)
  1386. {
  1387. u32 lfbmode, fbiinit1, fbiinit2, fbiinit3, fbiinit5, fbiinit6=0;
  1388. int ntiles;
  1389. struct pci_dev * sst_dev = sst_info->dev;
  1391. f_dprintk("sst_set_par(%dx%d)n", par->xDim, par->yDim);
  1392. f_ddprintk("hSyncOn hSyncOff vSyncOn vSyncOffn");
  1393. f_ddprintk("%-7d %-8d %-7d %-8dn",
  1394.            par->hSyncOn, par->hSyncOff,
  1395.            par->vSyncOn, par->vSyncOff);
  1396. f_ddprintk("hBackPorch vBackPorch xDim yDim Freqn");
  1397. f_ddprintk("%-10d %-10d %-4d %-4d %-8dn",
  1398.            par->hBackPorch, par->vBackPorch,
  1399.            par->xDim, par->yDim, par->freq);
  1401. if (!par->valid) {
  1402. BUG();
  1403. return -1;
  1404. }
  1405. sst_write(NOPCMD, 0);
  1406. sst_wait_idle();
  1407. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE, PCI_EN_INIT_WR);
  1408. sst_set_bits(FBIINIT1, VIDEO_RESET);
  1409. sst_set_bits(FBIINIT0, FBI_RESET | FIFO_RESET);
  1410. sst_unset_bits(FBIINIT2, EN_DRAM_REFRESH);
  1411. sst_wait_idle();
  1413. /*sst_unset_bits (FBIINIT0, FBI_RESET); / reenable FBI ? */
  1415. sst_write(BACKPORCH, par->vBackPorch << 16 | (par->hBackPorch - 2));
  1416. sst_write(VIDEODIMENSIONS, par->yDim << 16 | (par->xDim - 1));
  1417. sst_write(HSYNC, (par->hSyncOff - 1) << 16 | (par->hSyncOn - 1));
  1418. sst_write(VSYNC,       par->vSyncOff << 16 | par->vSyncOn);
  1420. fbiinit2=sst_read(FBIINIT2);
  1421. fbiinit3=sst_read(FBIINIT3);
  1423. /* everything is reset. we enable fbiinit2/3 remap : dac acces ok */
  1424. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
  1425.                        PCI_EN_INIT_WR | PCI_REMAP_DAC );
  1427. sst_info->dac_sw.set_vidmod(sst_info, par->bpp);
  1429. /* set video clock */
  1430. sst_info->dac_sw.set_pll(sst_info, &par->pll, VID_CLOCK);
  1432. /* disable fbiinit2/3 remap */
  1433. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
  1434.                        PCI_EN_INIT_WR);
  1436. /* restore fbiinit2/3 */
  1437. sst_write(FBIINIT2,fbiinit2);
  1438. sst_write(FBIINIT3,fbiinit3);
  1440. fbiinit1 = (sst_read(FBIINIT1) & VIDEO_MASK)
  1441.             | EN_DATA_OE
  1442.             | EN_BLANK_OE
  1443.             | EN_HVSYNC_OE
  1444.             | EN_DCLK_OE
  1445. /*             | (15 << TILES_IN_X_SHIFT)*/
  1446.             | SEL_INPUT_VCLK_2X
  1447. /*             | (2 << VCLK_2X_SEL_DEL_SHIFT)
  1448.             | (2 << VCLK_DEL_SHIFT)*/;
  1449. /* try with vclk_in_delay =0 (bits 29:30) , vclk_out_delay =0 (bits(27:28)
  1450.  in (near) future set them accordingly to revision + resolution (cf glide)
  1451.  first understand what it stands for :)
  1452.  FIXME: there are some artefacts... check for the vclk_in_delay
  1453.  lets try with 6ns delay in both vclk_out & in...
  1454.  doh... they're still there :
  1455. */
  1457. ntiles = par->tiles_in_X;
  1458. if (IS_VOODOO2(sst_info)) {
  1459. fbiinit1 |= ((ntiles & 0x20) >> 5) << TILES_IN_X_MSB_SHIFT
  1460.             | ((ntiles & 0x1e) >> 1) << TILES_IN_X_SHIFT ;
  1461. /* as the only value of importance for us in fbiinit6 is tiles in X (lsb),
  1462.    and as reading fbinit 6 will return crap (see FBIINIT6_DEFAULT) we just
  1463.    write our value. BTW due to the dac unable to read odd number of tiles, this
  1464.    field is always null ... */
  1465. fbiinit6 = (ntiles & 0x1) << TILES_IN_X_LSB_SHIFT;
  1466. }
  1467. else
  1468. fbiinit1 |= ntiles << TILES_IN_X_SHIFT;
  1470. switch(par->bpp) {
  1471. case 16:
  1472. fbiinit1 |=  SEL_SOURCE_VCLK_2X_SEL;
  1473. break;
  1474. #ifdef EN_24_32_BPP
  1475. case 24:
  1476. case 32:
  1477. /* orig sst_set_bits(FBIINIT1, SEL_SOURCE_VCLK_2X_DIV2 | EN_24BPP); */
  1478. fbiinit1 |= SEL_SOURCE_VCLK_2X_SEL | EN_24BPP;
  1479. break;
  1480. #endif
  1481. default:
  1482. dprintk("bug line %d: bad depth '%u'n", __LINE__,
  1483. par->bpp );
  1484. return 0;
  1485. break;
  1486. }
  1487. sst_write(FBIINIT1, fbiinit1);
  1488. if (IS_VOODOO2(sst_info)) {
  1489. sst_write(FBIINIT6, fbiinit6);
  1490. fbiinit5=sst_read(FBIINIT5) & FBIINIT5_MASK ;
  1491. if (par->vmode & FB_VMODE_INTERLACED)
  1492. fbiinit5 |= INTERLACE;
  1493. if (par->vmode & FB_VMODE_DOUBLE )
  1494. fbiinit5 |= VDOUBLESCAN;
  1495. if (par->sync & FB_SYNC_HOR_HIGH_ACT)
  1496. fbiinit5 |= HSYNC_HIGH;
  1497. if (par->sync & FB_SYNC_VERT_HIGH_ACT)
  1498. fbiinit5 |= VSYNC_HIGH;
  1499. sst_write(FBIINIT5, fbiinit5);
  1500. }
  1501. sst_wait_idle();
  1502. sst_unset_bits(FBIINIT1, VIDEO_RESET);
  1503. sst_unset_bits(FBIINIT0, FBI_RESET | FIFO_RESET);
  1504. sst_set_bits(FBIINIT2, EN_DRAM_REFRESH);
  1505. /* disables fbiinit writes */
  1506. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE, PCI_EN_FIFO_WR);
  1508. /* set lfbmode : set mode + front buffer for reads/writes
  1509.    + disable pipeline */
  1510. switch(par->bpp) {
  1511. case 16:
  1512. lfbmode = LFB_565;
  1513. break;
  1514. #ifdef EN_24_32_BPP
  1515. case 24:
  1516. lfbmode = LFB_888;
  1517. break;
  1518. case 32:
  1519. lfbmode = LFB_8888;
  1520. break;
  1521. #endif
  1522. default:
  1523. dprintk("bug line %d: bad depth '%u'n", __LINE__,
  1524. par->bpp );
  1525. return 0;
  1526. break;
  1527. }
  1529. #if defined(__BIG_ENDIAN)
  1530. /* enable byte-swizzle functionality in hardware */
  1531. lfbmode |= ( LFB_WORD_SWIZZLE_WR | LFB_BYTE_SWIZZLE_WR |
  1532.      LFB_WORD_SWIZZLE_RD | LFB_BYTE_SWIZZLE_RD );
  1533. #endif
  1535. if (clipping) {
  1536. sst_write(LFBMODE, lfbmode | EN_PXL_PIPELINE);
  1537. /*
  1538.  * Set "clipping" dimensions. If clipping is disabled and
  1539.  * writes to offscreen areas of the framebuffer are performed,
  1540.  * the "behaviour is undefined" (_very_ undefined) - Urs
  1541.  */
  1542. /* btw, it requires enabling pixel pipeline in LFBMODE .
  1543.    off screen read/writes will just wrap and read/print pixels
  1544.    on screen. Ugly but not that dangerous */
  1546. f_ddprintk("setting clipping dimensions 0..%d, 0..%dn",
  1547.             par->xDim-1, par->yDim-1);
  1549. sst_write(CLIP_LEFT_RIGHT, par->xDim );
  1550. sst_write(CLIP_LOWY_HIGHY, par->yDim );
  1551. sst_set_bits(FBZMODE, EN_CLIPPING | EN_RGB_WRITE);
  1552. } else {
  1553. /* no clipping : direct access, no pipeline */
  1554. sst_write(LFBMODE, lfbmode );
  1555. }
  1557. sst_info->current_par = *par ;
  1558. return 1;
  1559. }
  1561. static void sst_set_vidmod_att_ti(struct sstfb_info * sst_info, const int bpp)
  1562. {
  1563. u8 cr0;
  1565. f_dprintk("sst_set_vidmod_att_ti(bpp: %d)n", bpp);
  1567. sst_dac_write(DACREG_WMA, 0);  /* backdoor */
  1568. sst_dac_read(DACREG_RMR); /* read 4 times RMR */
  1569. sst_dac_read(DACREG_RMR);
  1570. sst_dac_read(DACREG_RMR);
  1571. sst_dac_read(DACREG_RMR);
  1572. /* the fifth time,  CR0 is read */
  1573. cr0 = sst_dac_read(DACREG_RMR);
  1575. sst_dac_write(DACREG_WMA, 0);  /* backdoor */
  1576. sst_dac_read(DACREG_RMR); /* read 4 times RMR */
  1577. sst_dac_read(DACREG_RMR);
  1578. sst_dac_read(DACREG_RMR);
  1579. sst_dac_read(DACREG_RMR);
  1580. /* cr0 */
  1581. switch(bpp) {
  1582. case 16:
  1583. sst_dac_write(DACREG_RMR, (cr0 & 0x0f) | DACREG_CR0_16BPP);
  1584. break;
  1585. #ifdef EN_24_32_BPP
  1586. case 24:
  1587. case 32:
  1588. sst_dac_write(DACREG_RMR, (cr0 & 0x0f) | DACREG_CR0_24BPP);
  1589. break;
  1590. #endif
  1591. default:
  1592. dprintk("bug line %d: bad depth '%u'n", __LINE__, bpp);
  1593. break;
  1594. }
  1595. }
  1597. static void sst_set_vidmod_ics(struct sstfb_info * sst_info, const int bpp)
  1598. {
  1599. f_dprintk("sst_set_vidmod_ics(bpp: %d)n", bpp);
  1600. switch(bpp) {
  1601. case 16:
  1602. sst_dac_write(DACREG_ICS_CMD, DACREG_ICS_CMD_16BPP);
  1603. break;
  1604. #ifdef EN_24_32_BPP
  1605. case 24:
  1606. case 32:
  1607. sst_dac_write(DACREG_ICS_CMD, DACREG_ICS_CMD_24BPP);
  1608. break;
  1609. #endif
  1610. default:
  1611. dprintk("bug line %d: bad depth '%u'n", __LINE__, bpp);
  1612. break;
  1613. }
  1614. }
  1616. static int __devinit sst_init(struct sstfb_info *sst_info)
  1617. {
  1618. struct pll_timing gfx_timings;
  1619. struct sst_spec * spec;
  1620. struct pci_dev * sst_dev = sst_info->dev;
  1621. int Fout;
  1622. u32 fbiinit0, fbiinit1, fbiinit4;
  1624. spec = &voodoo_spec[sst_info->type];
  1625. f_dprintk("sst_initn");
  1626. f_ddprintk(" fbiinit0   fbiinit1   fbiinit2   fbiinit3   fbiinit4  "
  1627.            " fbiinit6n");
  1628. f_ddprintk("%0#10x %0#10x %0#10x %0#10x %0#10x %0#10xn",
  1629.             sst_read(FBIINIT0), sst_read(FBIINIT1), sst_read(FBIINIT2),
  1630.             sst_read(FBIINIT3), sst_read(FBIINIT4), sst_read(FBIINIT6));
  1631. /* disable video clock */
  1632. pci_write_config_dword(sst_dev, PCI_VCLK_DISABLE,0);
  1634. /* enable writing to init registers ,disable pci fifo*/
  1635. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE, PCI_EN_INIT_WR);
  1636. /* reset video */
  1637. sst_set_bits(FBIINIT1, VIDEO_RESET);
  1638. sst_wait_idle();
  1639. /* reset gfx + pci fifo */
  1640. sst_set_bits(FBIINIT0, FBI_RESET | FIFO_RESET);
  1641. sst_wait_idle();
  1643. /* unreset fifo */
  1644. /*sst_unset_bits(FBIINIT0, FIFO_RESET);
  1645. sst_wait_idle();*/
  1646. /* unreset FBI */
  1647. /*sst_unset_bits(FBIINIT0, FBI_RESET);
  1648. sst_wait_idle();*/
  1650. /* disable dram refresh */
  1651. sst_unset_bits(FBIINIT2, EN_DRAM_REFRESH);
  1652. sst_wait_idle();
  1653. /* remap fbinit2/3 to dac */
  1654. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
  1655.                                PCI_EN_INIT_WR | PCI_REMAP_DAC );
  1656. /* detect dac type */
  1657. if (!sst_detect_dactype(sst_info)) {
  1658. eprintk("Unknown dac typen");
  1659. //FIXME watch it : we are not in a safe state , bad bad bad .
  1660. return 0;
  1661. }
  1663. /* set graphic clock */
  1664. sst_info->gfx_clock = spec->default_gfx_clock;
  1665. if ((gfxclk >10 ) && (gfxclk < spec->max_gfxclk)) {
  1666. iprintk ("Using supplied graphic freq : %dMHzn", gfxclk);
  1667.  sst_info->gfx_clock = gfxclk *1000;
  1668. } else if (gfxclk) {
  1669. wprintk ("You fool, %dMhz is way out of spec! Using defaultn", gfxclk);
  1670. }
  1672. sst_calc_pll(sst_info->gfx_clock, &Fout, &gfx_timings);
  1673. sst_info->dac_sw.set_pll(sst_info, &gfx_timings, GFX_CLOCK);
  1675. /* disable fbiinit remap */
  1676. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
  1677.                        PCI_EN_INIT_WR| PCI_EN_FIFO_WR );
  1678. /* defaults init registers */
  1679. /* FbiInit0: unreset gfx, unreset fifo */
  1680. fbiinit0 = FBIINIT0_DEFAULT;
  1681. fbiinit1 = FBIINIT1_DEFAULT;
  1682. fbiinit4 = FBIINIT4_DEFAULT;
  1683. if (vgapass)
  1684. fbiinit0 &= ~EN_VGA_PASSTHROUGH;
  1685. else
  1686. fbiinit0 |= EN_VGA_PASSTHROUGH;
  1687. if (slowpci) {
  1688. fbiinit1 |= SLOW_PCI_WRITES;
  1689. fbiinit4 |= SLOW_PCI_READS;
  1690. } else {
  1691. fbiinit1 &= ~SLOW_PCI_WRITES;
  1692. fbiinit4 &= ~SLOW_PCI_READS;
  1693. }
  1694. sst_write(FBIINIT0, fbiinit0);
  1695. sst_wait_idle();
  1696. sst_write(FBIINIT1, fbiinit1);
  1697. sst_wait_idle();
  1698. sst_write(FBIINIT2, FBIINIT2_DEFAULT);
  1699. sst_wait_idle();
  1700. sst_write(FBIINIT3, FBIINIT3_DEFAULT);
  1701. sst_wait_idle();
  1702. sst_write(FBIINIT4, fbiinit4);
  1703. sst_wait_idle();
  1704. if (IS_VOODOO2(sst_info)) {
  1705. sst_write(FBIINIT6, FBIINIT6_DEFAULT);
  1706. sst_wait_idle();
  1707. }
  1709. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE, PCI_EN_FIFO_WR );
  1710. pci_write_config_dword(sst_dev, PCI_VCLK_ENABLE, 0);
  1712. return 1;
  1713. }
  1715. static void  __devexit sst_shutdown(struct sstfb_info *sst_info)
  1716. {
  1717. struct pci_dev * sst_dev = sst_info->dev;
  1718. struct pll_timing gfx_timings;
  1719. int Fout;
  1721. f_dprintk("sst_shutdownn");
  1722. /* reset video, gfx, fifo, disable dram + remap fbiinit2/3 */
  1723. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE, PCI_EN_INIT_WR);
  1724. sst_set_bits(FBIINIT1, VIDEO_RESET | EN_BLANKING);
  1725. sst_unset_bits(FBIINIT2, EN_DRAM_REFRESH);
  1726. sst_set_bits(FBIINIT0, FBI_RESET | FIFO_RESET);
  1727. sst_wait_idle();
  1728. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
  1729.                        PCI_EN_INIT_WR | PCI_REMAP_DAC );
  1730. /*set 20Mhz gfx clock */
  1731. sst_calc_pll(20000, &Fout, &gfx_timings);
  1732. sst_info->dac_sw.set_pll(sst_info, &gfx_timings, GFX_CLOCK);
  1733. /* TODO maybe shutdown the dac, vrefresh and so on... */
  1734. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
  1735.                        PCI_EN_INIT_WR);
  1736. sst_unset_bits(FBIINIT0, FBI_RESET | FIFO_RESET | EN_VGA_PASSTHROUGH);
  1737. pci_write_config_dword(sst_dev, PCI_VCLK_DISABLE,0);
  1738. /* maybe keep fbiinit* and PCI_INIT_enable in the fb_info struct at the beginining ? */
  1739. pci_write_config_dword(sst_dev, PCI_INIT_ENABLE, 0);
  1741. }
  1743. /*
  1744.  * Interface to the world
  1745.  */
  1747. int  __init sstfb_setup(char *options)
  1748. {
  1749. char *this_opt;
  1751. f_dprintk("sstfb_setupn");
  1753. if (!options || !*options)
  1754. return 0;
  1756. for(this_opt = strtok(options, ","); this_opt;
  1757. this_opt = strtok(NULL, ",")) { //XXX
  1758. //XXX while ((this_opt = strsep(&options, ",")) != NULL) {
  1759. if (!*this_opt) continue;
  1761. f_ddprintk("option %sn", this_opt);
  1763. if (!strcmp(this_opt, "inverse")) {
  1764. inverse = 1;
  1765. fb_invert_cmaps();
  1766. }
  1767. else if (!strcmp(this_opt, "vganopass"))
  1768. vgapass = 0;
  1769. else if (!strcmp(this_opt, "vgapass"))
  1770. vgapass = 1;
  1771. else if (!strcmp(this_opt, "clipping"))
  1772.         clipping = 1;
  1773. else if (!strcmp(this_opt, "noclipping"))
  1774.         clipping = 0;
  1775. else if (!strcmp(this_opt, "fastpci"))
  1776.         slowpci = 0;
  1777. else if (!strcmp(this_opt, "slowpci"))
  1778.         slowpci = 1;
  1779. else if (!strncmp(this_opt, "mem:",4))
  1780. mem=simple_strtoul (this_opt+4, NULL, 0);
  1781. else if (!strncmp(this_opt, "gfxclk:",7))
  1782. gfxclk=simple_strtoul (this_opt+7, NULL, 0);
  1783. else if (!strncmp(this_opt, "dev:",4))
  1784. dev=simple_strtoul (this_opt+4, NULL, 0);
  1785. else
  1786. mode_option=this_opt;
  1787. }
  1788. return 0;
  1789. }
  1791. int __devinit sstfb_init(void)
  1792. {
  1793. f_dprintk("sstfb_initn");
  1794. dprintk("Compile date: "__DATE__" "__TIME__"n");
  1795. return pci_module_init(&sstfb_driver);
  1796. }
  1798. void __devexit sstfb_exit(void)
  1799. {
  1800. f_dprintk("sstfb_exitn");
  1801. pci_unregister_driver(&sstfb_driver);
  1802. }
  1804. #ifdef MODULE
  1805. module_init(sstfb_init);
  1806. module_exit(sstfb_exit);
  1807. #endif
  1809. static int __devinit sstfb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
  1810. {
  1811. struct fb_var_screeninfo var;
  1812. struct sstfb_info * sst_info;
  1813. struct sst_spec * spec;
  1814. int tmp,err;
  1815. f_dprintk("sstfb_proben");
  1817. /* dev >  0  the device is not the one asked for.   skip */
  1818. /* dev == 0  this is the device the user asked.     init */
  1819. /* dev == -1 we already inited the asked device.    skip */
  1820. /* dev < -1  init all devices. including this one.  init */
  1821. if ((dev == -1 ) || (dev-- > 0))
  1822. return -1;
  1824. if ((err=pci_enable_device(pdev))) {
  1825. eprintk("cannot enable devicen");
  1826. return err;
  1827. }
  1829. sst_info = (struct sstfb_info*)kmalloc(sizeof(*sst_info), GFP_KERNEL);
  1830. if (!sst_info)
  1831. goto fail_kmalloc;
  1832. pci_set_drvdata(pdev, sst_info);
  1833. sst_info->type = id->driver_data;
  1834. spec = &voodoo_spec[sst_info->type];
  1835. f_ddprintk("found device : %sn", spec->name);
  1837. sst_info->dev = pdev;
  1838. pci_read_config_byte(pdev, PCI_REVISION_ID, &sst_info->revision);
  1840. sst_info->mmio.base = pci_resource_start(pdev,0);
  1841. sst_info->video.base = sst_info->mmio.base+0x400000;
  1843. if (!request_mem_region(sst_info->mmio.base,0x400000,"sstfb MMIO")) {
  1844. eprintk ("cannot reserve mmio memoryn");
  1845. goto fail_mmio_mem;
  1846. }
  1848. if (!request_mem_region(sst_info->video.base,0x400000,"sstfb FB")) {
  1849. eprintk ("cannot reserve fb memoryn");
  1850. goto fail_fb_mem;
  1851. }
  1853. sst_info->mmio.vbase = (u_long) ioremap_nocache(sst_info->mmio.base, 0x400000);
  1854. if (!sst_info->mmio.vbase) {
  1855. eprintk("cannot remap register area %#lxn",
  1856.         sst_info->mmio.base);
  1857. goto fail_mmio_remap;
  1858. }
  1859. sst_info->video.vbase = (u_long) ioremap_nocache(sst_info->video.base, 0x400000);
  1860. if (!sst_info->video.vbase) {
  1861. eprintk("cannot remap framebuffer %#lxn",
  1862.         sst_info->video.base);
  1863. goto fail_fb_remap;
  1864. }
  1866. if(!sst_init(sst_info)) {
  1867. eprintk("Init failedn");
  1868. goto fail;
  1869. }
  1870. sst_get_memsize(sst_info, &sst_info->video.len);
  1871. strncpy(sst_info->info.modename, spec->name, 16);
  1873. iprintk("%s with %s dacn", sst_info->info.modename, sst_info->dac_sw.name);
  1874. iprintk("framebuffer at %#lx, mapped to %#lx,"
  1875.         " size %ldMbn",
  1876.         sst_info->video.base, sst_info->video.vbase,
  1877.         sst_info->video.len >> 20);
  1879. f_ddprintk("revision: %dn", sst_info->revision);
  1880. f_ddprintk("regbase_virt: %#lxn", sst_info->mmio.vbase);
  1881. f_ddprintk("membase_phys: %#lxn", sst_info->video.base);
  1882. f_ddprintk("fbbase_virt: %#lxn", sst_info->video.vbase);
  1884. sst_info->info.node       = -1 ;
  1885. sst_info->info.flags      = FBINFO_FLAG_DEFAULT;
  1886. sst_info->info.fbops      = &sstfb_ops;
  1887. sst_info->info.disp       = &sst_info->disp;
  1888. sst_info->info.changevar  = NULL;
  1889. sst_info->info.switch_con = &sstfbcon_switch;
  1890. sst_info->info.updatevar  = &sstfbcon_updatevar;
  1891. sst_info->info.blank      = &sstfbcon_blank;
  1893. tmp=0;
  1894. var = sstfb_default;
  1895. if ( mode_option  &&
  1896.      fb_find_mode(&var, &sst_info->info, mode_option,
  1897.                    NULL, 0, NULL, 16)) {
  1898. if (sstfb_set_var(&var, -1, &sst_info->info)) {
  1899. eprintk("can't set supplied video mode. Using defaultn");
  1900. var = sstfb_default;
  1901. } else {
  1902. /* set the new default */
  1903. sstfb_default = var;
  1904. tmp=1;  /* no need to set the mode. */
  1905. }
  1906. }
  1908. if (!tmp && sstfb_set_var(&var, -1, &sst_info->info)) {
  1909. eprintk("can't set default video mode.n");
  1910. goto fail;
  1911. }
  1912. /*clear fb */
  1913. memset_io(sst_info->video.vbase, 0, sst_info->video.len);
  1914. /* print some squares ... */
  1915. sstfb_test16(sst_info); /* FIXME this is only for 16bpp */
  1917. /* register fb */
  1918. if (register_framebuffer(&sst_info->info) < 0) {
  1919. eprintk("can't register framebuffer.n");
  1920. goto fail;
  1921. }
  1922. printk(KERN_INFO "fb%d: %s frame buffer devicen",
  1923.        GET_FB_IDX(sst_info->info.node),sst_info->info.modename);
  1925. return 0;
  1927. fail:
  1928. iounmap((void *)sst_info->video.base);
  1929. fail_fb_remap:
  1930. iounmap((void *)sst_info->mmio.base);
  1931. fail_mmio_remap:
  1932. release_mem_region(sst_info->video.base,0x400000);
  1933. fail_fb_mem:
  1934. release_mem_region(sst_info->mmio.base,0x400000);
  1935. fail_mmio_mem:
  1936. kfree(sst_info);
  1937. fail_kmalloc:
  1938. return -ENXIO;  /* no voodoo detected */
  1939. }
  1941. static void __devexit sstfb_remove(struct pci_dev *pdev)
  1942. {
  1943. struct sstfb_info * sst_info;
  1945. f_dprintk("sstfb_removen");
  1946. sst_info=pci_get_drvdata(pdev);
  1947. sst_shutdown(sst_info);
  1949. unregister_framebuffer(&sst_info->info);
  1950. iounmap((void*)sst_info->video.vbase);
  1951. iounmap((void*)sst_info->mmio.vbase);
  1952. release_mem_region(sst_info->video.base,0x400000);
  1953. release_mem_region(sst_info->mmio.base,0x400000);
  1954. kfree(sst_info);
  1955. }
  1958. /*
  1959.  * console driver
  1960.  */
  1961. static int sstfbcon_switch(int con, struct fb_info *info)
  1962. {
  1963. #define sst_info  ((struct sstfb_info *) info)
  1964. struct sstfb_par par;
  1966. f_dprintk("sstfbcon_switch(con: %d)n",con);
  1967. f_ddprintk("currcon: %dn", sst_info->currcon);
  1968. v_dprintk("currcon: %dn", sst_info->currcon);
  1970. if (sst_info->currcon >=  0) {
  1971. if (fb_display[sst_info->currcon].cmap.len)
  1972. fb_get_cmap(&fb_display[sst_info->currcon].cmap, 1,
  1973.             sstfb_getcolreg, info);
  1974. }
  1975. sst_info->currcon = con;
  1976. fb_display[con].var.activate = FB_ACTIVATE_NOW;
  1978. print_var(&fb_display[con].var, "&fb_display[con: %d].var",con);
  1979. sstfb_decode_var(&fb_display[con].var, &par, sst_info);
  1980. if (memcmp(&par,&(sst_info->current_par),sizeof(par))) {
  1981. sstfb_set_par(&par, sst_info);
  1982. }
  1983. sstfb_install_cmap(con, info);
  1984. return 0;
  1985. #undef sst_info
  1986. }
  1988. static int sstfbcon_updatevar(int con, struct fb_info *info)
  1989. {
  1990. f_dprintk("sstfbcon_updatevarn");
  1991. return -EINVAL;
  1992. }
  1994. static void sstfbcon_blank(int blank, struct fb_info *info)
  1995. {
  1996. f_dprintk("sstfbcon_blank(level %d)n", blank);
  1997. }
  2000. /* print some squares on the fb (presuming 16bpp)  */
  2001. static void sstfb_test16(struct sstfb_info *sst_info)
  2002. {
  2003. int i,j;
  2004. u_long p;
  2005. u_long fbbase_virt = sst_info->video.vbase;
  2007. f_dprintk("sstfb_test16n");
  2008. /* rect blanc 20x100+200+0 */
  2009. for (i=0 ; i< 100; i++) {
  2010.   p = fbbase_virt + 2048 *i+400;
  2011.   for (j=0 ; j < 10 ; j++) {
  2012.     writel( 0xffffffff, p);
  2013.     p+=4;
  2014.   }
  2015. }
  2016. /* rect bleu 180x200+0+0 */
  2017. for (i=0 ; i< 200; i++) {
  2018.   p = fbbase_virt + 2048 *i;
  2019.   for (j=0 ; j < 90 ; j++) {
  2020.     writel(0x001f001f,p);
  2021.     p+=4;
  2022.   }
  2023. }
  2024. /* carre vert 40x40+100+0 */
  2025. for (i=0 ; i< 40 ; i++) {
  2026.   p = fbbase_virt + 2048 *i + 200;
  2027.   for (j=0; j <20;j++) {
  2028.     writel(0x07e007e0, p);
  2029.     p+=4;
  2030.   }
  2031. }
  2032. /*carre rouge 40x40+100+40 */
  2033. for (i=0; i<40; i++) {
  2034.   p = fbbase_virt + 2048 * (i+40) + 200;
  2035.   for (j=0; j <20;j++) {
  2036.     writel( 0xf800f800, p);
  2037.     p+=4;
  2038.   }
  2039. }
  2040. }
  2042. /* print some squares on the fb (24/32bpp)  */
  2043. #ifdef EN_24_32_BPP
  2044. static void sstfb_test32(struct sstfb_info *sst_info)
  2045. {
  2046. int i,j;
  2047. u_long p;
  2048. u_long fbbase_virt = sst_info->video.vbase;
  2050. f_dprintk("sstfb_test32n");
  2051. /* rect blanc 20x100+200+0 */
  2052. for (i=0 ; i< 100; i++) {
  2053.   p = fbbase_virt + 4096*i + 800;
  2054.   for (j=0 ; j < 20 ; j++) {
  2055.     writel( 0x00ffffff, p);
  2056.     p+=4;
  2057.   }
  2058. }
  2059. /* rect bleu 180x200+0+0 */
  2060. for (i=0 ; i< 200; i++) {
  2061.   p = fbbase_virt + 4096 * i;
  2062.   for (j=0 ; j < 180 ; j++) {
  2063.     writel(0x000000ff,p);
  2064.     p+=4;
  2065.   }
  2066. }
  2067. /* carre vert 40x40+100+0 */
  2068. for (i=0 ; i< 40 ; i++) {
  2069.   p = fbbase_virt + 4096 *i + 400;
  2070.   for (j=0; j <40;j++) {
  2071.     writel(0x0000ff00, p);
  2072.     p+=4;
  2073.   }
  2074. }
  2075. /*carre rouge 40x40+100+10 */
  2076. for (i=0; i<40; i++) {
  2077.   p = fbbase_virt + 4096 * (i+40) + 400;
  2078.   for (j=0; j <40;j++) {
  2079.     writel( 0x00ff0000, p);
  2080.     p+=4;
  2081.   }
  2082. }
  2083. }
  2084. #endif /* EN_24_32_BPP */
  2086. MODULE_AUTHOR("(c) 2000,2002 Ghozlane Toumi <gtoumi@laposte.net>");
  2087. MODULE_DESCRIPTION("FBDev driver for 3dfx Voodoo Graphics and Voodoo2 based video boards");
  2088. MODULE_LICENSE("GPL");
  2090. MODULE_PARM(mem, "i");
  2091. MODULE_PARM_DESC(mem, "Size of frame buffer memory in MiB (1, 2, 4 Mb, default=autodetect)");
  2092. MODULE_PARM(vgapass, "i");
  2093. MODULE_PARM_DESC(vgapass, "Enable VGA PassThrough cable (0 or 1) (default=0)");
  2094. MODULE_PARM(inverse, "i");
  2095. MODULE_PARM_DESC(inverse, "Inverse colormap (0 or 1) (default=0)");
  2096. MODULE_PARM(clipping , "i");
  2097. MODULE_PARM_DESC(clipping, "Enable clipping (slower, safer) (0 or 1) (default=1)");
  2098. MODULE_PARM(gfxclk , "i");
  2099. MODULE_PARM_DESC(gfxclk, "Force graphic chip frequency in Mhz. DANGEROUS. (default=auto)");
  2100. MODULE_PARM(slowpci, "i");
  2101. MODULE_PARM_DESC(slowpci, "Uses slow PCI settings (0 or 1) (default=0)");
  2102. MODULE_PARM(dev,"i");
  2103. MODULE_PARM_DESC(dev , "Attach to device ID (0..n) (default=1st device)");
  2105. /*
  2106.  * Overrides for Emacs so that we follow Linus's tabbing style.
  2107.  * ---------------------------------------------------------------------------
  2108.  * Local variables:
  2109.  * c-basic-offset: 8
  2110.  * End:
  2111.  */
  2113. #if 0
  2114. void __Dump_regs (struct sstfb_info * sst_info)
  2115. {
  2116. struct { u32 reg ; char * reg_name;}  pci_regs [] =  {
  2117. { PCI_INIT_ENABLE, "initenable"},
  2118. { PCI_VCLK_ENABLE, "enable vclk"},
  2119. { PCI_VCLK_DISABLE, "disable vclk"},
  2120. };
  2122. struct { u32 reg ; char * reg_name;}  sst_regs [] =  {
  2123. {FBIINIT0,"fbiinit0"},
  2124. {FBIINIT1,"fbiinit1"},
  2125. {FBIINIT2,"fbiinit2"},
  2126. {FBIINIT3,"fbiinit3"},
  2127. {FBIINIT4,"fbiinit4"},
  2128. {FBIINIT5,"fbiinit5"},
  2129. {FBIINIT6,"fbiinit6"},
  2130. {FBIINIT7,"fbiinit7"},
  2131. {LFBMODE,"lfbmode"},
  2132. {FBZMODE,"fbzmode"},
  2133. };
  2134. int pci_s = sizeof(pci_regs)/sizeof(*pci_regs);
  2135. int sst_s = sizeof(sst_regs)/sizeof(*sst_regs);
  2136. u32 pci_res[pci_s];
  2137. u32 sst_res[sst_s];
  2139. struct pci_dev * dev = sst_info->dev;
  2141. int i;
  2143. for (i=0; i < pci_s ; i++ ) {
  2144. pci_read_config_dword ( dev, pci_regs[i].reg , &pci_res[i]) ;
  2145. }
  2146. for (i=0; i < sst_s ; i++ ) {
  2147. sst_res[i]=sst_read(sst_regs[i].reg);
  2148. }
  2150. dprintk ("Dump regsn");
  2151. for (i=0; i < pci_s ; i++ ) {
  2152. dprintk("%s = %0#10xn", pci_regs[i].reg_name , pci_res[i]) ;
  2153. }
  2154. for (i=0; i < sst_s ; i++ ) {
  2155. dprintk("%s = %0#10xn", sst_regs[i].reg_name , sst_res[i]) ;
  2156. }
  2157. }
  2158. #endif