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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sstfb.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：57k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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