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

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

Linux/Unix编程

开发平台：

Unix_Linux

pm3fb.c：源码内容
  1. /*
  2.  *  linux/drivers/video/pm3fb.c -- 3DLabs Permedia3 frame buffer device
  3.  *  
  4.  *  Copyright (C) 2001 Romain Dolbeau <dolbeau@irisa.fr>
  5.  *  Based on code written by:
  6.  *           Sven Luther, <luther@dpt-info.u-strasbg.fr>
  7.  *           Alan Hourihane, <alanh@fairlite.demon.co.uk>
  8.  *           Russel King, <rmk@arm.linux.org.uk>
  9.  *  Based on linux/drivers/video/skeletonfb.c:
  10.  * Copyright (C) 1997 Geert Uytterhoeven
  11.  *  Based on linux/driver/video/pm2fb.c:
  12.  *      Copyright (C) 1998-1999 Ilario Nardinocchi (nardinoc@CS.UniBO.IT)
  13.  *      Copyright (C) 1999 Jakub Jelinek (jakub@redhat.com)
  14.  *
  15.  *  This file is subject to the terms and conditions of the GNU General Public
  16.  *  License. See the file COPYING in the main directory of this archive for
  17.  *  more details.
  18.  *
  19.  *  $Header: /cvsroot/linux/drivers/video/pm3fb.c,v 1.1 2002/02/25 19:11:06 marcelo Exp $
  20.  *
  21.  *  CHANGELOG:
  22.  *  Mon Feb 11 10:35:48 MET 2002, v 1.4.11B: Cosmetic update.
  23.  *  Wed Jan 23 14:16:59 MET 2002, v 1.4.11: Preliminary 2.5.x support, patch for 2.5.2.
  24.  *  Wed Nov 28 11:08:29 MET 2001, v 1.4.10: potential bug fix for SDRAM-based board, patch for 2.4.16.
  25.  *  Thu Sep 20 10:24:42 MET DST 2001, v 1.4.9: sync bug fix, preliminary flatpanel support, better timings.
  26.  *  Tue Aug 28 10:13:01 MET DST 2001, v 1.4.8: memory timings check, minor bug fixes.
  27.  *  Wed Jul 18 19:06:14 CEST 2001, v 1.4.7: Mode fix (800x600-100, 1024x768-100 changed), using HW panning + accel bug fix.
  28.  *  Mon Jun 25 10:33:56 MET DST 2001, v 1.4.6: Depth 12 fix, chip reset ioctl, moved memory erase ioctl to DEBUG.
  29.  *  Wed Jun 20 11:13:08 MET DST 2001, v 1.4.5: Fixed missing blinking cursor in 8bpp, code cleaning, memory erase IOCTL.
  30.  *  Mon Jun 18 16:00:27 CEST 2001, v 1.4.4: Depth 12 (RGBA 4444) support, code cleaning.
  31.  *  Fri Jun 15 13:53:01 CEST 2001, v 1.4.3: Removed warnings, depth 15 support, add 'depth' option.
  32.  *  Thu Jun 14 10:13:52 MET DST 2001, v 1.4.2: Fixed depth switching bug, preliminary 15bpp (RGB5551) support.
  33.  *  Thu Apr 12 11:16:45 MET DST 2001, v 1.4.1B: Doc updates.
  34.  *  Fri Apr  6 11:12:53 MET DST 2001, v 1.4.1: Configure.help, minor cleanup
  35.  *  Thu Mar 29 10:56:50 MET DST 2001, v 1.4.0: Module & module options support (note: linux patch changed, 2.2.19 added).
  36.  *  Thu Mar 15 15:30:31 MET 2001, v 1.3.2: Fixed mirroring bug on little-endian.
  37.  *  Wed Mar 14 21:25:54 CET 2001, v 1.3.1: Fixed bug in BlockMove (_bmov).
  38.  *  Tue Mar 13 10:53:19 MET 2001, v 1.3.0: Character drawing hardware support (in all width between 1 and 16), fixes.
  39.  *  Thu Mar  8 10:20:16 MET 2001, v 1.2.2: Better J2000 support, "font:" option.
  40.  *  Tue Mar  6 21:25:04 CET 2001, v 1.2.1: Better acceleration support.
  41.  *  Mon Mar  5 21:54:17 CET 2001, v 1.2.0: Partial acceleration support (clear & bmove)
  42.  *  Mon Mar  5 12:52:15 CET 2001, v 1.1.3: Big pan_display fix.
  43.  *  Sun Mar  4 22:21:50 CET 2001, v 1.1.2: (numerous) bug fixes.
  44.  *  Fri Mar  2 15:54:07 CET 2001, v 1.1.1: Might have Appian J2000 support, resource mangement in 2.4
  45.  *  Wed Feb 28 18:21:35 CET 2001, v 1.1.0: Might have multiple boards support (added, but not yest tested)
  46.  *  Tue Feb 27 17:31:12 CET 2001, v 1.0.6: fixes boot-time mode select, add more default mode
  47.  *  Tue Feb 27 14:01:36 CET 2001, v 1.0.5: fixes (1.0.4 was broken for 2.2), cleaning up
  48.  *  Mon Feb 26 23:17:36 CET 2001, v 1.0.4: preliminary 2.4.x support, dropped (useless on pm3) partial product, more OF fix
  49.  *  Mon Feb 26 20:59:05 CET 2001, v 1.0.3: No more shadow register (and wasted memory), endianess fix, use OF-preset resolution by default
  50.  *  Wed Feb 21 22:09:30 CET 2001, v 1.0.2: Code cleaning for future multiboard support, better OF support, bugs fix
  51.  *  Wed Feb 21 19:58:56 CET 2001, v 1.0.1: OpenFirmware support, fixed memory detection, better debug support, code cleaning
  52.  *  Wed Feb 21 14:47:06 CET 2001, v 1.0.0: First working version
  53.  */
  55. #include <linux/config.h>
  56. #include <linux/module.h>
  57. #include <linux/version.h>
  58. #include <linux/kernel.h>
  59. #include <linux/errno.h>
  60. #include <linux/string.h>
  61. #include <linux/mm.h>
  62. #include <linux/tty.h>
  63. #include <linux/slab.h>
  64. #include <linux/vmalloc.h>
  65. #include <linux/delay.h>
  66. #include <linux/interrupt.h>
  67. #include <linux/fb.h>
  68. #include <linux/init.h>
  69. #include <linux/pci.h>
  70. #include <linux/ioport.h>
  72. #include <video/fbcon.h>
  73. #include <video/fbcon-mfb.h>
  74. #include <video/fbcon-cfb2.h>
  75. #include <video/fbcon-cfb4.h>
  76. #include <video/fbcon-cfb8.h>
  77. #include <video/fbcon-cfb16.h>
  78. #include <video/fbcon-cfb24.h>
  79. #include <video/fbcon-cfb32.h>
  81. #include <asm/io.h>
  82. #include <asm/uaccess.h>
  84. #ifdef CONFIG_FB_OF
  85. #include <asm/prom.h>
  86. #endif
  88. #include "pm3fb.h"
  90. /* ************************************* */
  91. /* ***** The various "global" data ***** */
  92. /* ************************************* */
  94. /* those will need a rework for multiple board support */
  95. /* Driver name */
  96. static const char permedia3_name[16] = "Permedia3";
  98. /* the fb_par struct, mandatory */
  99. struct pm3fb_par {
  100. u32 pixclock; /* pixclock in KHz */
  102. u32 width; /* width of virtual screen */
  103. u32 height; /* height of virtual screen */
  105. u32 hsstart; /* horiz. sync start */
  106. u32 hsend; /* horiz. sync end */
  107. u32 hbend; /* horiz. blank end (also gate end) */
  108. u32 htotal; /* total width (w/ sync & blank) */
  110. u32 vsstart; /* vert. sync start */
  111. u32 vsend; /* vert. sync end */
  112. u32 vbend; /* vert. blank end */
  113. u32 vtotal; /* total height (w/ sync & blank) */
  115. u32 stride; /* screen stride */
  116. u32 base; /* screen base (xoffset+yoffset) in 128 bits unit */
  117. /* NOTE : unlike other pm3 stuff above, stored *after* shiftbpp. don't ask */
  118. u32 depth; /* screen depth (8, 12, 15, 16 or 32) */
  119. u32 video; /* video control (hsync,vsync) */
  120. };
  122. /* memory timings */
  123. struct pm3fb_timings
  124. {
  125. unsigned long caps;
  126. unsigned long timings;
  127. unsigned long control;
  128. unsigned long refresh;
  129. unsigned long powerdown;
  130. };
  131. typedef enum pm3fb_timing_result { pm3fb_timing_ok, pm3fb_timing_problem, pm3fb_timing_retry } pm3fb_timing_result;
  132. #define PM3FB_UNKNOWN_TIMING_VALUE ((unsigned long)-1)
  133. #define PM3FB_UNKNOWN_TIMINGS { PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE }
  135. /* the fb_info struct, mandatory */
  136. struct pm3fb_info {
  137. struct fb_info_gen gen;
  138. unsigned long board_num; /* internal board number */
  139. unsigned long use_current;
  140. struct pm3fb_par *current_par;
  141. struct pci_dev *dev;    /* PCI device */
  142. #ifdef SUPPORT_FB_OF
  143. struct device_node *dn; /* OF node for the PCI device */
  144. #endif /* SUPPORT_FB_OF */
  145. unsigned long board_type; /* index in the cardbase */
  146. unsigned char *fb_base; /* framebuffer memory base */
  147. u32 fb_size; /* framebuffer memory size */
  148. unsigned char *p_fb; /* physical address of frame buffer */
  149. unsigned char *v_fb; /* virtual address of frame buffer */
  150. unsigned char *pIOBase; /* physical address of registers region, must be rg_base or rg_base+PM2_REGS_SIZE depending on the host endianness */
  151. unsigned char *vIOBase; /* address of registers after ioremap() */
  152. struct {
  153. u8 transp;
  154. u8 red;
  155. u8 green;
  156. u8 blue;
  157. } palette[256];
  158. union {
  159. #ifdef FBCON_HAS_CFB16
  160. u16 cmap12[16]; /* RGBA 4444 */
  161. u16 cmap15[16]; /* RGBA 5551 */
  162. u16 cmap16[16]; /* RGBA 5650 */
  163. #endif
  164. #ifdef FBCON_HAS_CFB32
  165. u32 cmap32[16];
  166. #endif
  167. } cmap;
  168. struct pm3fb_timings memt;
  169. };
  171. /* regular resolution database*/
  172. static struct {
  173. char name[16];
  174. struct pm3fb_par user_mode;
  175. } mode_base[] __initdata = {
  176. {
  177. "default-800x600", {
  178. 49500, 800, 600, 16, 96, 256, 1056, 1, 4, 25, 625,
  179.     800, 0, 8,
  180.     PM3VideoControl_ENABLE |
  181.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  182.     |
  183.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  184.     | PM3VideoControl_PIXELSIZE_8BIT}}, {
  185. "1024x768-74", {
  186. 78752, 1024, 768, 32, 128, 304, 1328, 1, 4, 38,
  187.     806, 1024, 0, 8,
  188.     PM3VideoControl_ENABLE |
  189.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  190.     |
  191.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  192.     | PM3VideoControl_PIXELSIZE_8BIT}}, {
  193. "1024x768-74-32", {
  194. 78752, 1024, 768, 32, 128, 304, 1328, 1, 4, 38,
  195. 806, 1024, 0, 32,
  196. PM3VideoControl_ENABLE |
  197. PM3VideoControl_HSYNC_ACTIVE_HIGH
  198. |
  199. PM3VideoControl_VSYNC_ACTIVE_HIGH
  200. | PM3VideoControl_PIXELSIZE_32BIT}},
  201. /* Generated mode : "1600x1024", for the SGI 1600SW flat panel*/
  202. {
  203. "SGI1600SW", {
  204. 108000, 1600, 1024, 16, 56, 104, 1704, 3, 6, 32,
  205. 1056, 1600, 0, 8,
  206. PM3VideoControl_ENABLE|
  207. PM3VideoControl_HSYNC_ACTIVE_LOW|PM3VideoControl_VSYNC_ACTIVE_LOW|
  208. PM3VideoControl_PIXELSIZE_32BIT}}, 
  209. /* ##### auto-generated mode, by fbtimings2pm3 */
  210. /* Generated mode : "640x480-60" */
  211. {
  212. "640x480-60", {
  213. 25174, 640, 480, 16, 112, 160, 800, 10, 12, 45,
  214.     525, 640, 0, 8,
  215.     PM3VideoControl_ENABLE |
  216.     PM3VideoControl_HSYNC_ACTIVE_LOW
  217.     |
  218.     PM3VideoControl_VSYNC_ACTIVE_LOW
  219.     | PM3VideoControl_PIXELSIZE_8BIT}},
  220. /* Generated mode : "640x480-72" */
  221. {
  222. "640x480-72", {
  223. 31199, 640, 480, 24, 64, 192, 832, 9, 12, 40, 520,
  224.     640, 0, 8,
  225.     PM3VideoControl_ENABLE |
  226.     PM3VideoControl_HSYNC_ACTIVE_LOW
  227.     |
  228.     PM3VideoControl_VSYNC_ACTIVE_LOW
  229.     | PM3VideoControl_PIXELSIZE_8BIT}},
  230. /* Generated mode : "640x480-75" */
  231. {
  232. "640x480-75", {
  233. 31499, 640, 480, 16, 80, 200, 840, 1, 4, 20, 500,
  234.     640, 0, 8,
  235.     PM3VideoControl_ENABLE |
  236.     PM3VideoControl_HSYNC_ACTIVE_LOW
  237.     |
  238.     PM3VideoControl_VSYNC_ACTIVE_LOW
  239.     | PM3VideoControl_PIXELSIZE_8BIT}},
  240. /* Generated mode : "640x480-90" */
  241. {
  242. "640x480-90", {
  243. 39909, 640, 480, 32, 72, 192, 832, 25, 39, 53, 533,
  244.     640, 0, 8,
  245.     PM3VideoControl_ENABLE |
  246.     PM3VideoControl_HSYNC_ACTIVE_LOW
  247.     |
  248.     PM3VideoControl_VSYNC_ACTIVE_LOW
  249.     | PM3VideoControl_PIXELSIZE_8BIT}},
  250. /* Generated mode : "640x480-100" */
  251. {
  252. "640x480-100", {
  253. 44899, 640, 480, 32, 160, 208, 848, 22, 34, 51,
  254.     531, 640, 0, 8,
  255.     PM3VideoControl_ENABLE |
  256.     PM3VideoControl_HSYNC_ACTIVE_LOW
  257.     |
  258.     PM3VideoControl_VSYNC_ACTIVE_LOW
  259.     | PM3VideoControl_PIXELSIZE_8BIT}},
  260. /* Generated mode : "800x600-48-lace" */
  261. /* INTERLACED NOT SUPPORTED
  262.   {"800x600-48-lace", {35999, 800, 600, 80, 208, 264, 1064, 11, 23, 102, 702, 800, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
  263.    INTERLACED NOT SUPPORTED */
  264. /* Generated mode : "800x600-56" */
  265. {
  266. "800x600-56", {
  267. 35999, 800, 600, 24, 96, 224, 1024, 1, 3, 25, 625,
  268.     800, 0, 8,
  269.     PM3VideoControl_ENABLE |
  270.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  271.     |
  272.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  273.     | PM3VideoControl_PIXELSIZE_8BIT}},
  274. /* Generated mode : "800x600-60" */
  275. {
  276. "800x600-60", {
  277. 40000, 800, 600, 40, 168, 256, 1056, 1, 5, 28, 628,
  278.     800, 0, 8,
  279.     PM3VideoControl_ENABLE |
  280.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  281.     |
  282.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  283.     | PM3VideoControl_PIXELSIZE_8BIT}},
  284. /* Generated mode : "800x600-70" */
  285. {
  286. "800x600-70", {
  287. 44899, 800, 600, 24, 168, 208, 1008, 9, 21, 36,
  288.     636, 800, 0, 8,
  289.     PM3VideoControl_ENABLE |
  290.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  291.     |
  292.     PM3VideoControl_VSYNC_ACTIVE_LOW
  293.     | PM3VideoControl_PIXELSIZE_8BIT}},
  294. /* Generated mode : "800x600-72" */
  295. {
  296. "800x600-72", {
  297. 50000, 800, 600, 56, 176, 240, 1040, 37, 43, 66,
  298.     666, 800, 0, 8,
  299.     PM3VideoControl_ENABLE |
  300.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  301.     |
  302.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  303.     | PM3VideoControl_PIXELSIZE_8BIT}},
  304. /* Generated mode : "800x600-75" */
  305. {
  306. "800x600-75", {
  307. 49497, 800, 600, 16, 96, 256, 1056, 1, 4, 25, 625,
  308.     800, 0, 8,
  309.     PM3VideoControl_ENABLE |
  310.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  311.     |
  312.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  313.     | PM3VideoControl_PIXELSIZE_8BIT}},
  314. /* Generated mode : "800x600-90" */
  315. {
  316. "800x600-90", {
  317. 56637, 800, 600, 8, 72, 192, 992, 8, 19, 35, 635,
  318.     800, 0, 8,
  319.     PM3VideoControl_ENABLE |
  320.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  321.     |
  322.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  323.     | PM3VideoControl_PIXELSIZE_8BIT}},
  324. /* Generated mode : "800x600-100", from /etc/fb.modes */
  325. /* DISABLED, hsstart == 0
  326. {
  327. "800x600-100", {
  328. 67499, 800, 600, 0, 64, 280, 1080, 7, 11, 25, 625,
  329.     800, 0, 8,
  330.     PM3VideoControl_ENABLE |
  331.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  332.     |
  333.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  334.     | PM3VideoControl_PIXELSIZE_8BIT}},
  335. */
  336. /* Generated mode : "800x600-100", from ??? */
  337. {
  338. "800x600-100", {
  339. 69650, 800, 600, 64, 128, 288, 1088, 4, 10, 40, 640, 800, 0, 8,
  340. PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_LOW|
  341. PM3VideoControl_VSYNC_ACTIVE_LOW|PM3VideoControl_PIXELSIZE_8BIT}},
  342. /* Generated mode : "1024x768-43-lace" */
  343. /* INTERLACED NOT SUPPORTED
  344.   {"1024x768-43-lace", {44899, 1024, 768, 8, 184, 240, 1264, 1, 9, 49, 817, 1024, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
  345.    INTERLACED NOT SUPPORTED */
  346. /* Generated mode : "1024x768-60" */
  347. {
  348. "1024x768-60", {
  349. 64998, 1024, 768, 24, 160, 320, 1344, 3, 9, 38,
  350.     806, 1024, 0, 8,
  351.     PM3VideoControl_ENABLE |
  352.     PM3VideoControl_HSYNC_ACTIVE_LOW
  353.     |
  354.     PM3VideoControl_VSYNC_ACTIVE_LOW
  355.     | PM3VideoControl_PIXELSIZE_8BIT}},
  356. /* Generated mode : "1024x768-70" */
  357. {
  358. "1024x768-70", {
  359. 74996, 1024, 768, 24, 160, 304, 1328, 3, 9, 38,
  360.     806, 1024, 0, 8,
  361.     PM3VideoControl_ENABLE |
  362.     PM3VideoControl_HSYNC_ACTIVE_LOW
  363.     |
  364.     PM3VideoControl_VSYNC_ACTIVE_LOW
  365.     | PM3VideoControl_PIXELSIZE_8BIT}},
  366. /* Generated mode : "1024x768-72" */
  367. {
  368. "1024x768-72", {
  369. 74996, 10224, 768, 24, 160, 264, 10488, 3, 9, 38,
  370.     806, 10224, 0, 8,
  371.     PM3VideoControl_ENABLE |
  372.     PM3VideoControl_HSYNC_ACTIVE_LOW
  373.     |
  374.     PM3VideoControl_VSYNC_ACTIVE_LOW
  375.     | PM3VideoControl_PIXELSIZE_8BIT}},
  376. /* Generated mode : "1024x768-75" */
  377. {
  378. "1024x768-75", {
  379. 78746, 1024, 768, 16, 112, 288, 1312, 1, 4, 32,
  380.     800, 1024, 0, 8,
  381.     PM3VideoControl_ENABLE |
  382.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  383.     |
  384.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  385.     | PM3VideoControl_PIXELSIZE_8BIT}},
  386. /* Generated mode : "1024x768-90" */
  387. {
  388. "1024x768-90", {
  389. 100000, 1024, 768, 0, 96, 288, 1312, 21, 36, 77,
  390.     845, 1024, 0, 8,
  391.     PM3VideoControl_ENABLE |
  392.     PM3VideoControl_HSYNC_ACTIVE_LOW
  393.     |
  394.     PM3VideoControl_VSYNC_ACTIVE_LOW
  395.     | PM3VideoControl_PIXELSIZE_8BIT}},
  396. /* Generated mode : "1024x768-100", from /etc/fb.modes */
  397. /* DISABLED, vsstart == 0
  398. {
  399. "1024x768-100", {
  400. 109998, 1024, 768, 0, 88, 368, 1392, 0, 8, 24, 792,
  401.     1024, 0, 8,
  402.     PM3VideoControl_ENABLE |
  403.     PM3VideoControl_HSYNC_ACTIVE_LOW
  404.     |
  405.     PM3VideoControl_VSYNC_ACTIVE_LOW
  406.     | PM3VideoControl_PIXELSIZE_8BIT}},
  407. */
  408. /* Generated mode : "1024x768-100", from ??? */
  409. {
  410. "1024x768-100", {
  411. 115500, 1024, 768, 32, 224, 416, 1440, 3, 13, 34, 802, 1024, 0, 8,
  412. PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_LOW|
  413. PM3VideoControl_VSYNC_ACTIVE_LOW|PM3VideoControl_PIXELSIZE_8BIT}},
  414. /* Generated mode : "1152x864-43-lace" */
  415. /* INTERLACED NOT SUPPORTED
  416.   {"1152x864-43-lace", {64998, 1152, 864, 72, 200, 264, 1416, 78, 87, 191, 1055, 1152, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
  417.    INTERLACED NOT SUPPORTED */
  418. /* Generated mode : "1152x864-47-lace" */
  419. /* INTERLACED NOT SUPPORTED
  420.   {"1152x864-47-lace", {64998, 1152, 864, 88, 216, 296, 1448, 30, 39, 83, 947, 1152, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
  421.    INTERLACED NOT SUPPORTED */
  422. /* Generated mode : "1152x864-60" */
  423. {
  424. "1152x864-60", {
  425. 80000, 1152, 864, 64, 176, 304, 1456, 6, 11, 52,
  426.     916, 1152, 0, 8,
  427.     PM3VideoControl_ENABLE |
  428.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  429.     |
  430.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  431.     | PM3VideoControl_PIXELSIZE_8BIT}},
  432. /* Generated mode : "1152x864-70" */
  433. {
  434. "1152x864-70", {
  435. 100000, 1152, 864, 40, 192, 360, 1512, 13, 24, 81,
  436.     945, 1152, 0, 8,
  437.     PM3VideoControl_ENABLE |
  438.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  439.     |
  440.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  441.     | PM3VideoControl_PIXELSIZE_8BIT}},
  442. /* Generated mode : "1152x864-75" */
  443. {
  444. "1152x864-75", {
  445. 109998, 1152, 864, 24, 168, 312, 1464, 45, 53, 138,
  446.     1002, 1152, 0, 8,
  447.     PM3VideoControl_ENABLE |
  448.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  449.     |
  450.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  451.     | PM3VideoControl_PIXELSIZE_8BIT}},
  452. /* Generated mode : "1152x864-80" */
  453. {
  454. "1152x864-80", {
  455. 109998, 1152, 864, 16, 128, 288, 1440, 30, 37, 94,
  456.     958, 1152, 0, 8,
  457.     PM3VideoControl_ENABLE |
  458.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  459.     |
  460.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  461.     | PM3VideoControl_PIXELSIZE_8BIT}},
  462. /* Generated mode : "1280x1024-43-lace" */
  463. /* INTERLACED NOT SUPPORTED
  464.   {"1280x1024-43-lace", {80000, 1024, 1024, 80, 160, 320, 1344, 50, 60, 125, 1149, 1024, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
  465.    INTERLACED NOT SUPPORTED */
  466. /* Generated mode : "1280x1024-47-lace" */
  467. /* INTERLACED NOT SUPPORTED
  468.   {"1280x1024-47-lace", {80000, 1280, 1024, 80, 160, 320, 1600, 1, 11, 29, 1053, 1280, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
  469.    INTERLACED NOT SUPPORTED */
  470. /* Generated mode : "1280x1024-60" */
  471. {
  472. "1280x1024-60", {
  473. 107991, 1280, 1024, 48, 160, 408, 1688, 1, 4, 42,
  474.     1066, 1280, 0, 8,
  475.     PM3VideoControl_ENABLE |
  476.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  477.     |
  478.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  479.     | PM3VideoControl_PIXELSIZE_8BIT}},
  480. /* Generated mode : "1280x1024-70" */
  481. {
  482. "1280x1024-70", {
  483. 125992, 1280, 1024, 80, 192, 408, 1688, 1, 6, 42,
  484.     1066, 1280, 0, 8,
  485.     PM3VideoControl_ENABLE |
  486.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  487.     |
  488.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  489.     | PM3VideoControl_PIXELSIZE_8BIT}},
  490. /* Generated mode : "1280x1024-74" */
  491. {
  492. "1280x1024-74", {
  493. 134989, 1280, 1024, 32, 176, 432, 1712, 0, 30, 40,
  494.     1064, 1280, 0, 8,
  495.     PM3VideoControl_ENABLE |
  496.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  497.     |
  498.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  499.     | PM3VideoControl_PIXELSIZE_8BIT}},
  500. /* Generated mode : "1280x1024-75" */
  501. {
  502. "1280x1024-75", {
  503. 134989, 1280, 1024, 16, 160, 408, 1688, 1, 4, 42,
  504.     1066, 1280, 0, 8,
  505.     PM3VideoControl_ENABLE |
  506.     PM3VideoControl_HSYNC_ACTIVE_HIGH
  507.     |
  508.     PM3VideoControl_VSYNC_ACTIVE_HIGH
  509.     | PM3VideoControl_PIXELSIZE_8BIT}},
  510. /* Generated mode : "1600x1200-60" */
  511. {
  512. "1600x1200-60", {
  513. 155981, 1600, 1200, 32, 192, 448, 2048, 10, 18, 70,
  514.     1270, 1600, 0, 8,
  515.     PM3VideoControl_ENABLE |
  516.     PM3VideoControl_HSYNC_ACTIVE_LOW
  517.     |
  518.     PM3VideoControl_VSYNC_ACTIVE_LOW
  519.     | PM3VideoControl_PIXELSIZE_8BIT}},
  520. /* Generated mode : "1600x1200-66" */
  521. {
  522. "1600x1200-66", {
  523. 171998, 1600, 1200, 40, 176, 480, 2080, 3, 6, 53,
  524.     1253, 1600, 0, 8,
  525.     PM3VideoControl_ENABLE |
  526.     PM3VideoControl_HSYNC_ACTIVE_LOW
  527.     |
  528.     PM3VideoControl_VSYNC_ACTIVE_LOW
  529.     | PM3VideoControl_PIXELSIZE_8BIT}},
  530. /* Generated mode : "1600x1200-76" */
  531. {
  532. "1600x1200-76", {
  533. 197980, 1600, 1200, 40, 176, 480, 2080, 3, 8, 50,
  534.     1250, 1600, 0, 8,
  535.     PM3VideoControl_ENABLE |
  536.     PM3VideoControl_HSYNC_ACTIVE_LOW
  537.     |
  538.     PM3VideoControl_VSYNC_ACTIVE_LOW
  539.     | PM3VideoControl_PIXELSIZE_8BIT}},
  540. /* ##### end of auto-generated mode */
  541. {
  542. "",}
  543. };
  545. /* more mandatory stuff (see skeletonfb.c + framebuffer driver HOWTO */
  546. static struct pm3fb_info fb_info[PM3_MAX_BOARD];
  547. static struct pm3fb_par current_par[PM3_MAX_BOARD];
  548. static int current_par_valid[PM3_MAX_BOARD];
  549. /* to allow explicit filtering of board */
  550. short bus[PM3_MAX_BOARD];
  551. short slot[PM3_MAX_BOARD];
  552. short func[PM3_MAX_BOARD];
  553. short disable[PM3_MAX_BOARD];
  554. short noaccel[PM3_MAX_BOARD];
  555. char fontn[PM3_MAX_BOARD][PM3_FONTNAME_SIZE];
  556. short depth[PM3_MAX_BOARD];
  557. short flatpanel[PM3_MAX_BOARD];
  558. static struct display disp[PM3_MAX_BOARD];
  559. static char g_options[PM3_OPTIONS_SIZE] __initdata = "pm3fb,dummy";
  560. short printtimings = 0;
  561. short forcesize[PM3_MAX_BOARD];
  563. /* ********************* */
  564. /* ***** prototype ***** */
  565. /* ********************* */
  566. /* card-specific */
  567. static void pm3fb_j2000_setup(struct pm3fb_info *l_fb_info);
  568. /* permedia3-specific */
  569. static pm3fb_timing_result pm3fb_preserve_memory_timings(struct pm3fb_info *l_fb_info);
  570. static pm3fb_timing_result pm3fb_try_memory_timings(struct pm3fb_info *l_fb_info);
  571. static void pm3fb_write_memory_timings(struct pm3fb_info *l_fb_info);
  572. static unsigned long pm3fb_read_dac_reg(struct pm3fb_info *l_fb_info,
  573. unsigned long r);
  574. static unsigned long pm3fb_CalculateClock(struct pm3fb_info *l_fb_info, unsigned long reqclock, /* In kHz units */
  575.   unsigned long refclock, /* In kHz units */
  576.   unsigned char *prescale, /* ClkPreScale */
  577.   unsigned char *feedback, /* ClkFeedBackScale */
  578.   unsigned char *postscale
  579.   /* ClkPostScale */ );
  580. static void pm3fb_clear_memory(struct pm3fb_info *l_fb_info, u32 cc);
  581. static void pm3fb_clear_colormap(struct pm3fb_info *l_fb_info, unsigned char r, unsigned char g, unsigned char b);
  582. static void pm3fb_common_init(struct pm3fb_info *l_fb_info);
  583. static int pm3fb_Shiftbpp(struct pm3fb_info *l_fb_info,
  584.   unsigned long depth, int v);
  585. static int pm3fb_Unshiftbpp(struct pm3fb_info *l_fb_info,
  586.     unsigned long depth, int v);
  587. static void pm3fb_mapIO(struct pm3fb_info *l_fb_info);
  588. static void pm3fb_unmapIO(struct pm3fb_info *l_fb_info);
  589. #if defined(PM3FB_MASTER_DEBUG) && (PM3FB_MASTER_DEBUG >= 2)
  590. static void pm3fb_show_cur_mode(struct pm3fb_info *l_fb_info);
  591. #endif
  592. static void pm3fb_show_cur_timing(struct pm3fb_info *l_fb_info);
  593. static void pm3fb_write_mode(struct pm3fb_info *l_fb_info);
  594. static void pm3fb_read_mode(struct pm3fb_info *l_fb_info,
  595.     struct pm3fb_par *curpar);
  596. static unsigned long pm3fb_size_memory(struct pm3fb_info *l_fb_info);
  597. /* accelerated permedia3-specific */
  598. #ifdef PM3FB_USE_ACCEL
  599. static void pm3fb_wait_pm3(struct pm3fb_info *l_fb_info);
  600. static void pm3fb_init_engine(struct pm3fb_info *l_fb_info);
  601. #ifdef FBCON_HAS_CFB32
  602. static void pm3fb_cfb32_clear(struct vc_data *conp,
  603.       struct display *p,
  604.       int sy, int sx, int height, int width);
  605. static void pm3fb_cfb32_clear_margins(struct vc_data *conp,
  606.       struct display *p, int bottom_only);
  607. #endif /* FBCON_HAS_CFB32 */
  608. #ifdef FBCON_HAS_CFB16
  609. static void pm3fb_cfb16_clear(struct vc_data *conp,
  610.       struct display *p,
  611.       int sy, int sx, int height, int width);
  612. static void pm3fb_cfb16_clear_margins(struct vc_data *conp,
  613.       struct display *p, int bottom_only);
  614. #endif /* FBCON_HAS_CFB16 */
  615. #ifdef FBCON_HAS_CFB8
  616. static void pm3fb_cfb8_clear(struct vc_data *conp,
  617.      struct display *p,
  618.      int sy, int sx, int height, int width);
  619. static void pm3fb_cfb8_clear_margins(struct vc_data *conp,
  620.      struct display *p, int bottom_only);
  621. #endif /* FBCON_HAS_CFB8 */
  622. #if defined(FBCON_HAS_CFB8) || defined(FBCON_HAS_CFB16) || defined(FBCON_HAS_CFB32)
  623. static void pm3fb_cfbX_bmove(struct display *p,
  624.      int sy, int sx,
  625.      int dy, int dx, int height, int width);
  626. static void pm3fb_cfbX_putc(struct vc_data *conp, struct display *p,
  627.     int c, int yy, int xx);
  628. static void pm3fb_cfbX_putcs(struct vc_data *conp, struct display *p,
  629.      const unsigned short *s, int count, int yy,
  630.      int xx);
  631. static void pm3fb_cfbX_revc(struct display *p, int xx, int yy);
  632. #endif /* FBCON_HAS_CFB8 || FBCON_HAS_CFB16 || FBCON_HAS_CFB32 */
  633. #endif /* PM3FB_USE_ACCEL */
  634. /* pre-init */
  635. static void pm3fb_mode_setup(char *mode, unsigned long board_num);
  636. static void pm3fb_pciid_setup(char *pciid, unsigned long board_num);
  637. static char *pm3fb_boardnum_setup(char *options, unsigned long *bn);
  638. static void pm3fb_real_setup(char *options);
  639. /* fbdev */
  640. static int pm3fb_open(struct fb_info *info, int user);
  641. static int pm3fb_release(struct fb_info *info, int user);
  642. static int pm3fb_encode_fix(struct fb_fix_screeninfo *fix,
  643.     const void *par, struct fb_info_gen *info);
  644. static int pm3fb_decode_var(const struct fb_var_screeninfo *var,
  645.     void *par, struct fb_info_gen *info);
  646. static void pm3fb_encode_depth(struct fb_var_screeninfo *var, long d);
  647. static int pm3fb_encode_var(struct fb_var_screeninfo *var,
  648.     const void *par, struct fb_info_gen *info);
  649. static void pm3fb_get_par(void *par, struct fb_info_gen *info);
  650. static void pm3fb_set_par(const void *par, struct fb_info_gen *info);
  651. static void pm3fb_set_color(struct pm3fb_info *l_fb_info,
  652.     unsigned char regno, unsigned char r,
  653.     unsigned char g, unsigned char b);
  654. static int pm3fb_getcolreg(unsigned regno, unsigned *red, unsigned *green,
  655.    unsigned *blue, unsigned *transp,
  656.    struct fb_info *info);
  657. static int pm3fb_setcolreg(unsigned regno, unsigned red, unsigned green,
  658.    unsigned blue, unsigned transp,
  659.    struct fb_info *info);
  660. static int pm3fb_blank(int blank_mode, struct fb_info_gen *info);
  661. static void pm3fb_set_disp(const void *par, struct display *disp,
  662.    struct fb_info_gen *info);
  663. static void pm3fb_detect(void);
  664. static int pm3fb_pan_display(const struct fb_var_screeninfo *var,
  665.      struct fb_info_gen *info);
  666. static int pm3fb_ioctl(struct inode *inode, struct file *file,
  667.                        u_int cmd, u_long arg, int con,
  668.        struct fb_info *info);
  671. /* the struct that hold them together */
  672. #ifdef KERNEL_2_2
  673. struct fbgen_hwswitch pm3fb_switch = {
  674. pm3fb_detect, pm3fb_encode_fix, pm3fb_decode_var, pm3fb_encode_var,
  675. pm3fb_get_par, pm3fb_set_par, pm3fb_getcolreg, pm3fb_setcolreg,
  676. pm3fb_pan_display, pm3fb_blank, pm3fb_set_disp
  677. };
  679. static struct fb_ops pm3fb_ops = {
  680. pm3fb_open, pm3fb_release,
  681. fbgen_get_fix, fbgen_get_var, fbgen_set_var,
  682. fbgen_get_cmap, fbgen_set_cmap, fbgen_pan_display, pm3fb_ioctl,
  683.     NULL, NULL
  684. };
  685. #endif /* KERNEL_2_2 */
  686. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  687. struct fbgen_hwswitch pm3fb_switch = {
  688. pm3fb_detect, pm3fb_encode_fix, pm3fb_decode_var, pm3fb_encode_var,
  689. pm3fb_get_par, pm3fb_set_par, pm3fb_getcolreg, pm3fb_setcolreg,
  690. pm3fb_pan_display, pm3fb_blank, pm3fb_set_disp
  691. };
  693. static struct fb_ops pm3fb_ops = {
  694. THIS_MODULE,
  695. pm3fb_open, pm3fb_release,
  696. fbgen_get_fix, fbgen_get_var, fbgen_set_var,
  697. fbgen_get_cmap, fbgen_set_cmap, fbgen_pan_display, pm3fb_ioctl, NULL, NULL
  698. };
  699. #endif /* KERNEL_2_4 or KERNEL_2_5 */
  700. #ifdef PM3FB_USE_ACCEL
  701. #ifdef FBCON_HAS_CFB32
  702. static struct display_switch pm3fb_cfb32 = {
  703. fbcon_cfb32_setup, pm3fb_cfbX_bmove, pm3fb_cfb32_clear,
  704. pm3fb_cfbX_putc, pm3fb_cfbX_putcs, pm3fb_cfbX_revc,
  705. NULL /* cursor() */ , NULL /* set_font() */ ,
  706. pm3fb_cfb32_clear_margins,
  707. FONTWIDTHRANGE(1, 16) /* true only if accelerated... */
  708. };
  709. #endif /* FBCON_HAS_CFB32 */
  710. #ifdef FBCON_HAS_CFB16
  711. static struct display_switch pm3fb_cfb16 = {
  712. fbcon_cfb16_setup, pm3fb_cfbX_bmove, pm3fb_cfb16_clear,
  713. pm3fb_cfbX_putc, pm3fb_cfbX_putcs, pm3fb_cfbX_revc,
  714. NULL /* cursor() */ , NULL /* set_font() */ ,
  715. pm3fb_cfb16_clear_margins,
  716. FONTWIDTHRANGE(1, 16) /* true only if accelerated... */
  717. };
  718. #endif /* FBCON_HAS_CFB16 */
  719. #ifdef FBCON_HAS_CFB8
  720. static struct display_switch pm3fb_cfb8 = {
  721. fbcon_cfb8_setup, pm3fb_cfbX_bmove, pm3fb_cfb8_clear,
  722. pm3fb_cfbX_putc, pm3fb_cfbX_putcs, pm3fb_cfbX_revc,
  723. NULL /* cursor() */ , NULL /* set_font() */ ,
  724. pm3fb_cfb8_clear_margins,
  725. FONTWIDTHRANGE(1, 16) /* true only if accelerated... */
  726. };
  727. #endif /* FBCON_HAS_CFB8 */
  728. #endif /* PM3FB_USE_ACCEL */
  730. /* ****************************** */
  731. /* ***** card-specific data ***** */
  732. /* ****************************** */
  733. struct pm3fb_card_timings {
  734. unsigned long memsize; /* 0 for last value (i.e. default) */
  735. struct pm3fb_timings memt;
  736. };
  738. static struct pm3fb_card_timings t_FormacProFormance3[] = {
  739. { 16, { 0x02e311b8, 0x06100205, 0x08000002, 0x00000079, 0x00000000} },
  740. { 0, { 0x02e311b8, 0x06100205, 0x08000002, 0x00000079, 0x00000000} } /* from 16 MB PF3 */
  741. };
  743. static struct pm3fb_card_timings t_AppianJeronimo2000[] = {
  744. { 32, { 0x02e311B8, 0x07424905, 0x0c000003, 0x00000061, 0x00000000} },
  745. { 0, { 0x02e311B8, 0x07424905, 0x0c000003, 0x00000061, 0x00000000} } /* from 32MB J2000 */
  746. };
  748. static struct pm3fb_card_timings t_3DLabsOxygenVX1[] = {
  749. { 32, { 0x30e311b8, 0x08501204, 0x08000002, 0x0000006b, 0x00000000} },
  750. { 0, { 0x30e311b8, 0x08501204, 0x08000002, 0x0000006b, 0x00000000} } /* from 32MB VX1 */
  751. };
  753. static struct {
  754. char cardname[32]; /* recognized card name */
  755. u16 subvendor; /* subvendor of the card */
  756. u16 subdevice; /* subdevice of the card */
  757. u8  func; /* function of the card to which the extra init apply */
  758. void (*specific_setup)(struct pm3fb_info *l_fb_info); /* card/func specific setup, done before _any_ FB access */
  759. struct pm3fb_card_timings *c_memt; /* defauls timings for the boards */
  760. } cardbase[] = {
  761. { "Unknown Permedia3 board", 0xFFFF, 0xFFFF, 0xFF, NULL, NULL },
  762. { "Appian Jeronimo 2000 head 1", 0x1097, 0x3d32, 1, NULL,
  763.   t_AppianJeronimo2000
  764. },
  765. { "Appian Jeronimo 2000 head 2", 0x1097, 0x3d32, 2, pm3fb_j2000_setup,
  766.   t_AppianJeronimo2000
  767. },
  768. { "Formac ProFormance 3", PCI_VENDOR_ID_3DLABS, 0x000a, 0, NULL, /* Formac use 3DLabs ID ?!? */
  769.   t_FormacProFormance3
  770. },
  771. { "3DLabs Permedia3 Create!", PCI_VENDOR_ID_3DLABS, 0x0127, 0, NULL, NULL },
  772. { "3DLabs Oxygen VX1 PCI", PCI_VENDOR_ID_3DLABS, 0x0121, 0, NULL,
  773.   t_3DLabsOxygenVX1
  774. },
  775. { "3DLabs Oxygen VX1 AGP", PCI_VENDOR_ID_3DLABS, 0x0125, 0, NULL, NULL },
  776. { "3DLabs Oxygen VX1-16 AGP", PCI_VENDOR_ID_3DLABS, 0x0140, 0, NULL, NULL },
  777. { "3DLabs Oxygen VX1-1600SW PCI", PCI_VENDOR_ID_3DLABS, 0x0800, 0, NULL, NULL },
  778. { "", 0x0, 0x0, 0, NULL, NULL }
  779. };
  781. /* ********************************** */
  782. /* ***** card-specific function ***** */
  783. /* ********************************** */
  784. static void pm3fb_j2000_setup(struct pm3fb_info *l_fb_info)
  785. {       /* the appian j2000 require more initialization of the second head */
  786. /* l_fb_info must point to the _second_ head of the J2000 */
  788. DTRACE;
  790. l_fb_info->memt = t_AppianJeronimo2000[0].memt; /* 32 MB, first and only j2000 ? */
  792. pm3fb_write_memory_timings(l_fb_info);
  793. }
  795. /* *************************************** */
  796. /* ***** permedia3-specific function ***** */
  797. /* *************************************** */
  798. static pm3fb_timing_result pm3fb_preserve_memory_timings(struct pm3fb_info *l_fb_info)
  799. {
  800. l_fb_info->memt.caps = PM3_READ_REG(PM3LocalMemCaps);
  801. l_fb_info->memt.timings = PM3_READ_REG(PM3LocalMemTimings);
  802. l_fb_info->memt.control = PM3_READ_REG(PM3LocalMemControl);
  803. l_fb_info->memt.refresh = PM3_READ_REG(PM3LocalMemRefresh);
  804. l_fb_info->memt.powerdown = PM3_READ_REG(PM3LocalMemPowerDown);
  806. if ((l_fb_info->memt.caps == PM3FB_UNKNOWN_TIMING_VALUE) ||
  807.     (l_fb_info->memt.timings == PM3FB_UNKNOWN_TIMING_VALUE) ||
  808.     (l_fb_info->memt.control == PM3FB_UNKNOWN_TIMING_VALUE) ||
  809.     (l_fb_info->memt.refresh == PM3FB_UNKNOWN_TIMING_VALUE) ||
  810.     (l_fb_info->memt.powerdown == PM3FB_UNKNOWN_TIMING_VALUE))
  811. {
  812. printk(KERN_ERR "pm3fb: invalid memory timings in permedia3 board #%ldn", l_fb_info->board_num);
  813. return(pm3fb_try_memory_timings(l_fb_info));
  814. }
  815. return(pm3fb_timing_ok);
  816. }
  818. static pm3fb_timing_result pm3fb_try_memory_timings(struct pm3fb_info *l_fb_info)
  819. {
  820. if (cardbase[l_fb_info->board_type].c_memt)
  821. {
  822. int i = 0, done = 0;
  823. while (!done)
  824. {
  825. if ((cardbase[l_fb_info->board_type].c_memt[i].memsize == l_fb_info->fb_size)
  826.     || !(cardbase[l_fb_info->board_type].c_memt[i].memsize))
  827. { /* will use the 0-sized timings by default */
  828. done = 1;
  829. l_fb_info->memt = cardbase[l_fb_info->board_type].c_memt[i].memt;
  830. printk(KERN_WARNING  "pm3fb: trying to use predefined memory timings for permedia3 board #%ld (%s, %ld MB)n",
  831.        l_fb_info->board_num,
  832.        cardbase[l_fb_info->board_type].cardname,
  833.        cardbase[l_fb_info->board_type].c_memt[i].memsize);
  834. pm3fb_write_memory_timings(l_fb_info);
  835. return(pm3fb_timing_retry);
  836. }
  837. i++;
  838. }
  839. } else
  840. return(pm3fb_timing_problem);
  841. return(pm3fb_timing_ok);
  842. }
  844. static void pm3fb_write_memory_timings(struct pm3fb_info *l_fb_info)
  845. {
  846. unsigned char m, n, p;
  847. unsigned long clockused;
  849. PM3_SLOW_WRITE_REG(PM3LocalMemCaps, l_fb_info->memt.caps);
  850. PM3_SLOW_WRITE_REG(PM3LocalMemTimings, l_fb_info->memt.timings);
  851. PM3_SLOW_WRITE_REG(PM3LocalMemControl, l_fb_info->memt.control);
  852. PM3_SLOW_WRITE_REG(PM3LocalMemRefresh, l_fb_info->memt.refresh);
  853. PM3_SLOW_WRITE_REG(PM3LocalMemPowerDown, l_fb_info->memt.powerdown);
  855. clockused =
  856.     pm3fb_CalculateClock(l_fb_info, 2 * 105000, PM3_REF_CLOCK, &m,
  857.  &n, &p);
  859. PM3_WRITE_DAC_REG(PM3RD_KClkPreScale, m);
  860. PM3_WRITE_DAC_REG(PM3RD_KClkFeedbackScale, n);
  861. PM3_WRITE_DAC_REG(PM3RD_KClkPostScale, p);
  862. PM3_WRITE_DAC_REG(PM3RD_KClkControl,
  863.   PM3RD_KClkControl_STATE_RUN |
  864.   PM3RD_KClkControl_SOURCE_PLL |
  865.   PM3RD_KClkControl_ENABLE);
  866. PM3_WRITE_DAC_REG(PM3RD_MClkControl,
  867.   PM3RD_MClkControl_STATE_RUN |
  868.   PM3RD_MClkControl_SOURCE_KCLK |
  869.   PM3RD_MClkControl_ENABLE);
  870. PM3_WRITE_DAC_REG(PM3RD_SClkControl,
  871.   PM3RD_SClkControl_STATE_RUN |
  872.   PM3RD_SClkControl_SOURCE_PCLK |
  873.   PM3RD_SClkControl_ENABLE);
  874. }
  876. static unsigned long pm3fb_read_dac_reg(struct pm3fb_info *l_fb_info,
  877. unsigned long r)
  878. {
  879. DASSERT((l_fb_info->vIOBase != (unsigned char *) (-1)),
  880. "l_fb_info->vIOBase mapped in read dac regn");
  881. PM3_SET_INDEX(r);
  882. mb();
  883. return (PM3_READ_REG(PM3RD_IndexedData));
  884. }
  886. /* Calculating various clock parameter */
  887. static unsigned long pm3fb_CalculateClock(struct pm3fb_info *l_fb_info, unsigned long reqclock, /* In kHz units */
  888.   unsigned long refclock, /* In kHz units */
  889.   unsigned char *prescale, /* ClkPreScale */
  890.   unsigned char *feedback, /* ClkFeedBackScale */
  891.   unsigned char *postscale
  892.   /* ClkPostScale */ )
  893. {
  894. int f, pre, post;
  895. unsigned long freq;
  896. long freqerr = 1000;
  897. unsigned long actualclock = 0;
  899. DTRACE;
  901. for (f = 1; f < 256; f++) {
  902. for (pre = 1; pre < 256; pre++) {
  903. for (post = 0; post < 5; post++) {
  904. freq =
  905.     ((2 * refclock * f) /
  906.      (pre * (1 << post)));
  907. if ((reqclock > freq - freqerr)
  908.     && (reqclock < freq + freqerr)) {
  909. freqerr =
  910.     (reqclock >
  911.      freq) ? reqclock -
  912.     freq : freq - reqclock;
  913. *feedback = f;
  914. *prescale = pre;
  915. *postscale = post;
  916. actualclock = freq;
  917. }
  918. }
  919. }
  920. }
  922. return (actualclock);
  923. }
  925. static int pm3fb_Shiftbpp(struct pm3fb_info *l_fb_info,
  926.   unsigned long depth, int v)
  927. {
  928. DTRACE;
  930. switch (depth) {
  931. case 8:
  932. return (v >> 4);
  933. case 12:
  934. case 15:
  935. case 16:
  936. return (v >> 3);
  937. case 32:
  938. return (v >> 2);
  939. }
  940. DPRINTK(1, "Unsupported depth %ldn", depth);
  941. return (0);
  942. }
  944. static int pm3fb_Unshiftbpp(struct pm3fb_info *l_fb_info,
  945.     unsigned long depth, int v)
  946. {
  947. DTRACE;
  949. switch (depth) {
  950. case 8:
  951. return (v << 4);
  952. case 12:
  953. case 15:
  954. case 16:
  955. return (v << 3);
  956. case 32:
  957. return (v << 2);
  958. }
  959. DPRINTK(1, "Unsupported depth %ldn", depth);
  960. return (0);
  961. }
  963. static void pm3fb_mapIO(struct pm3fb_info *l_fb_info)
  964. {
  965. DTRACE;
  967. l_fb_info->vIOBase =
  968.     ioremap((unsigned long) l_fb_info->pIOBase, PM3_REGS_SIZE);
  969. l_fb_info->v_fb =
  970.     ioremap((unsigned long) l_fb_info->p_fb, l_fb_info->fb_size);
  971. DPRINTK(2, "IO mapping : IOBase %lx / %lx, fb %lx / %lxn",
  972. (unsigned long) l_fb_info->pIOBase,
  973. (unsigned long) l_fb_info->vIOBase,
  974. (unsigned long) l_fb_info->p_fb,
  975. (unsigned long) l_fb_info->v_fb);
  976. }
  978. static void pm3fb_unmapIO(struct pm3fb_info *l_fb_info)
  979. {
  980. DTRACE;
  982. iounmap(l_fb_info->vIOBase);
  983. iounmap(l_fb_info->v_fb);
  984. l_fb_info->vIOBase = (unsigned char *) -1;
  985. l_fb_info->v_fb = (unsigned char *) -1;
  986. }
  988. #if defined(PM3FB_MASTER_DEBUG) && (PM3FB_MASTER_DEBUG >= 2)
  989. static void pm3fb_show_cur_mode(struct pm3fb_info *l_fb_info)
  990. {
  991. DPRINTK(2, "PM3Aperture0: 0x%08xn", PM3_READ_REG(PM3Aperture0));
  992. DPRINTK(2, "PM3Aperture1: 0x%08xn", PM3_READ_REG(PM3Aperture1));
  993. DPRINTK(2, "PM3ByAperture1Mode: 0x%08xn",
  994. PM3_READ_REG(PM3ByAperture1Mode));
  995. DPRINTK(2, "PM3ByAperture2Mode: 0x%08xn",
  996. PM3_READ_REG(PM3ByAperture2Mode));
  997. DPRINTK(2, "PM3ChipConfig: 0x%08xn", PM3_READ_REG(PM3ChipConfig));
  998. DPRINTK(2, "PM3FIFODis: 0x%08xn", PM3_READ_REG(PM3FIFODis));
  999. DPRINTK(2, "PM3HTotal: 0x%08xn", PM3_READ_REG(PM3HTotal));
  1000. DPRINTK(2, "PM3HbEnd: 0x%08xn", PM3_READ_REG(PM3HbEnd));
  1001. DPRINTK(2, "PM3HgEnd: 0x%08xn", PM3_READ_REG(PM3HgEnd));
  1002. DPRINTK(2, "PM3HsEnd: 0x%08xn", PM3_READ_REG(PM3HsEnd));
  1003. DPRINTK(2, "PM3HsStart: 0x%08xn", PM3_READ_REG(PM3HsStart));
  1004. DPRINTK(2, "PM3MemBypassWriteMask: 0x%08xn",
  1005. PM3_READ_REG(PM3MemBypassWriteMask));
  1006. DPRINTK(2, "PM3RD_IndexControl: 0x%08xn",
  1007. PM3_READ_REG(PM3RD_IndexControl));
  1008. DPRINTK(2, "PM3ScreenBase: 0x%08xn", PM3_READ_REG(PM3ScreenBase));
  1009. DPRINTK(2, "PM3ScreenStride: 0x%08xn",
  1010. PM3_READ_REG(PM3ScreenStride));
  1011. DPRINTK(2, "PM3VClkCtl: 0x%08xn", PM3_READ_REG(PM3VClkCtl));
  1012. DPRINTK(2, "PM3VTotal: 0x%08xn", PM3_READ_REG(PM3VTotal));
  1013. DPRINTK(2, "PM3VbEnd: 0x%08xn", PM3_READ_REG(PM3VbEnd));
  1014. DPRINTK(2, "PM3VideoControl: 0x%08xn",
  1015. PM3_READ_REG(PM3VideoControl));
  1016. DPRINTK(2, "PM3VsEnd: 0x%08xn", PM3_READ_REG(PM3VsEnd));
  1017. DPRINTK(2, "PM3VsStart: 0x%08xn", PM3_READ_REG(PM3VsStart));
  1019. DPRINTK(2, "PM3RD_ColorFormat: %ldn",
  1020. PM3_READ_DAC_REG(PM3RD_ColorFormat));
  1021. DPRINTK(2, "PM3RD_DACControl: %ldn",
  1022. PM3_READ_DAC_REG(PM3RD_DACControl));
  1023. DPRINTK(2, "PM3RD_DClk0FeedbackScale: %ldn",
  1024. PM3_READ_DAC_REG(PM3RD_DClk0FeedbackScale));
  1025. DPRINTK(2, "PM3RD_DClk0PostScale: %ldn",
  1026. PM3_READ_DAC_REG(PM3RD_DClk0PostScale));
  1027. DPRINTK(2, "PM3RD_DClk0PreScale: %ldn",
  1028. PM3_READ_DAC_REG(PM3RD_DClk0PreScale));
  1029. DPRINTK(2, "[not set] PM3RD_IndexControl: %ldn",
  1030. PM3_READ_DAC_REG(PM3RD_IndexControl));
  1031. DPRINTK(2, "PM3RD_MiscControl: %ldn",
  1032. PM3_READ_DAC_REG(PM3RD_MiscControl));
  1033. DPRINTK(2, "PM3RD_PixelSize: %ldn",
  1034. PM3_READ_DAC_REG(PM3RD_PixelSize));
  1035. DPRINTK(2, "PM3RD_SyncControl: %ldn",
  1036. PM3_READ_DAC_REG(PM3RD_SyncControl));
  1037. }
  1039. #endif /* defined(PM3FB_MASTER_DEBUG) && (PM3FB_MASTER_DEBUG >= 2) */
  1040. static void pm3fb_show_cur_timing(struct pm3fb_info *l_fb_info)
  1041. {
  1042. u16 subvendor, subdevice;
  1044. if ((!pci_read_config_word
  1045.      (l_fb_info->dev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor))
  1046.     &&
  1047.     (!pci_read_config_word
  1048.      (l_fb_info->dev, PCI_SUBSYSTEM_ID, &subdevice))) {
  1049. /* well, nothing... */
  1050. } else {
  1051. subvendor = subdevice = (u16)-1;
  1052. }
  1054. printk(KERN_INFO "pm3fb: memory timings for board #%ld (subvendor: 0x%hx, subdevice: 0x%hx)n", l_fb_info->board_num, subvendor, subdevice);
  1055. printk(KERN_INFO " PM3LocalMemCaps: 0x%08xn",
  1056.        PM3_READ_REG(PM3LocalMemCaps));
  1057. printk(KERN_INFO " PM3LocalMemTimings: 0x%08xn",
  1058.        PM3_READ_REG(PM3LocalMemTimings));
  1059. printk(KERN_INFO " PM3LocalMemControl: 0x%08xn",
  1060.        PM3_READ_REG(PM3LocalMemControl));
  1061. printk(KERN_INFO " PM3LocalMemRefresh: 0x%08xn",
  1062.        PM3_READ_REG(PM3LocalMemRefresh));
  1063. printk(KERN_INFO " PM3LocalMemPowerDown: 0x%08xn",
  1064.        PM3_READ_REG(PM3LocalMemPowerDown));
  1065. }
  1067. /* write the mode to registers */
  1068. static void pm3fb_write_mode(struct pm3fb_info *l_fb_info)
  1069. {
  1070. char tempsync = 0x00, tempmisc = 0x00;
  1071. DTRACE;
  1073. PM3_SLOW_WRITE_REG(PM3MemBypassWriteMask, 0xffffffff);
  1074. PM3_SLOW_WRITE_REG(PM3Aperture0, 0x00000000);
  1075. PM3_SLOW_WRITE_REG(PM3Aperture1, 0x00000000);
  1076. PM3_SLOW_WRITE_REG(PM3FIFODis, 0x00000007);
  1078. PM3_SLOW_WRITE_REG(PM3HTotal,
  1079.    pm3fb_Shiftbpp(l_fb_info,
  1080.   l_fb_info->current_par->depth,
  1081.   l_fb_info->current_par->htotal -
  1082.   1));
  1083. PM3_SLOW_WRITE_REG(PM3HsEnd,
  1084.    pm3fb_Shiftbpp(l_fb_info,
  1085.   l_fb_info->current_par->depth,
  1086.   l_fb_info->current_par->hsend));
  1087. PM3_SLOW_WRITE_REG(PM3HsStart,
  1088.    pm3fb_Shiftbpp(l_fb_info,
  1089.   l_fb_info->current_par->depth,
  1090.   l_fb_info->current_par->
  1091.   hsstart));
  1092. PM3_SLOW_WRITE_REG(PM3HbEnd,
  1093.    pm3fb_Shiftbpp(l_fb_info,
  1094.   l_fb_info->current_par->depth,
  1095.   l_fb_info->current_par->hbend));
  1096. PM3_SLOW_WRITE_REG(PM3HgEnd,
  1097.    pm3fb_Shiftbpp(l_fb_info,
  1098.   l_fb_info->current_par->depth,
  1099.   l_fb_info->current_par->hbend));
  1100. PM3_SLOW_WRITE_REG(PM3ScreenStride,
  1101.    pm3fb_Shiftbpp(l_fb_info,
  1102.   l_fb_info->current_par->depth,
  1103.   l_fb_info->current_par->stride));
  1104. PM3_SLOW_WRITE_REG(PM3VTotal, l_fb_info->current_par->vtotal - 1);
  1105. PM3_SLOW_WRITE_REG(PM3VsEnd, l_fb_info->current_par->vsend - 1);
  1106. PM3_SLOW_WRITE_REG(PM3VsStart,
  1107.    l_fb_info->current_par->vsstart - 1);
  1108. PM3_SLOW_WRITE_REG(PM3VbEnd, l_fb_info->current_par->vbend);
  1110. switch (l_fb_info->current_par->depth) {
  1111. case 8:
  1112. PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
  1113.    PM3ByApertureMode_PIXELSIZE_8BIT);
  1114. PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
  1115.    PM3ByApertureMode_PIXELSIZE_8BIT);
  1116. break;
  1118. case 12:
  1119. case 15:
  1120. case 16:
  1121. #ifndef __BIG_ENDIAN
  1122. PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
  1123.    PM3ByApertureMode_PIXELSIZE_16BIT);
  1124. PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
  1125.    PM3ByApertureMode_PIXELSIZE_16BIT);
  1126. #else
  1127. PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
  1128.    PM3ByApertureMode_PIXELSIZE_16BIT |
  1129.    PM3ByApertureMode_BYTESWAP_BADC);
  1130. PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
  1131.    PM3ByApertureMode_PIXELSIZE_16BIT |
  1132.    PM3ByApertureMode_BYTESWAP_BADC);
  1133. #endif /* ! __BIG_ENDIAN */
  1134. break;
  1136. case 32:
  1137. #ifndef __BIG_ENDIAN
  1138. PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
  1139.    PM3ByApertureMode_PIXELSIZE_32BIT);
  1140. PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
  1141.    PM3ByApertureMode_PIXELSIZE_32BIT);
  1142. #else
  1143. PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
  1144.    PM3ByApertureMode_PIXELSIZE_32BIT |
  1145.    PM3ByApertureMode_BYTESWAP_DCBA);
  1146. PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
  1147.    PM3ByApertureMode_PIXELSIZE_32BIT |
  1148.    PM3ByApertureMode_BYTESWAP_DCBA);
  1149. #endif /* ! __BIG_ENDIAN */
  1150. break;
  1152. default:
  1153. DPRINTK(1, "Unsupported depth %dn",
  1154. l_fb_info->current_par->depth);
  1155. break;
  1156. }
  1158. /*
  1159.  * Oxygen VX1 - it appears that setting PM3VideoControl and
  1160.  * then PM3RD_SyncControl to the same SYNC settings undoes
  1161.  * any net change - they seem to xor together.  Only set the
  1162.  * sync options in PM3RD_SyncControl.  --rmk
  1163.  */
  1164. {
  1165. unsigned int video = l_fb_info->current_par->video;
  1167. video &= ~(PM3VideoControl_HSYNC_MASK |
  1168.    PM3VideoControl_VSYNC_MASK);
  1169. video |= PM3VideoControl_HSYNC_ACTIVE_HIGH |
  1170.  PM3VideoControl_VSYNC_ACTIVE_HIGH;
  1171. PM3_SLOW_WRITE_REG(PM3VideoControl, video);
  1172. }
  1173. PM3_SLOW_WRITE_REG(PM3VClkCtl,
  1174.    (PM3_READ_REG(PM3VClkCtl) & 0xFFFFFFFC));
  1175. PM3_SLOW_WRITE_REG(PM3ScreenBase, l_fb_info->current_par->base);
  1176. PM3_SLOW_WRITE_REG(PM3ChipConfig,
  1177.    (PM3_READ_REG(PM3ChipConfig) & 0xFFFFFFFD));
  1179. {
  1180. unsigned char m; /* ClkPreScale */
  1181. unsigned char n; /* ClkFeedBackScale */
  1182. unsigned char p; /* ClkPostScale */
  1183. (void)pm3fb_CalculateClock(l_fb_info, l_fb_info->current_par->pixclock, PM3_REF_CLOCK, &m, &n, &p);
  1185. DPRINTK(2,
  1186. "Pixclock: %d, Pre: %d, Feedback: %d, Post: %dn",
  1187. l_fb_info->current_par->pixclock, (int) m, (int) n,
  1188. (int) p);
  1190. PM3_WRITE_DAC_REG(PM3RD_DClk0PreScale, m);
  1191. PM3_WRITE_DAC_REG(PM3RD_DClk0FeedbackScale, n);
  1192. PM3_WRITE_DAC_REG(PM3RD_DClk0PostScale, p);
  1193. }
  1194. /*
  1195.    PM3_WRITE_DAC_REG(PM3RD_IndexControl, 0x00);
  1196.  */
  1197. /*
  1198.    PM3_SLOW_WRITE_REG(PM3RD_IndexControl, 0x00);
  1199.  */
  1200. if ((l_fb_info->current_par->video & PM3VideoControl_HSYNC_MASK) ==
  1201.     PM3VideoControl_HSYNC_ACTIVE_HIGH)
  1202. tempsync |= PM3RD_SyncControl_HSYNC_ACTIVE_HIGH;
  1203. if ((l_fb_info->current_par->video & PM3VideoControl_VSYNC_MASK) ==
  1204.     PM3VideoControl_VSYNC_ACTIVE_HIGH)
  1205. tempsync |= PM3RD_SyncControl_VSYNC_ACTIVE_HIGH;
  1207. PM3_WRITE_DAC_REG(PM3RD_SyncControl, tempsync);
  1208. DPRINTK(2, "PM3RD_SyncControl: %dn", tempsync);
  1210. if (flatpanel[l_fb_info->board_num])
  1211. {
  1212. PM3_WRITE_DAC_REG(PM3RD_DACControl, PM3RD_DACControl_BLANK_PEDESTAL_ENABLE);
  1213. PM3_WAIT(2);
  1214. PM3_WRITE_REG(PM3VSConfiguration, 0x06);
  1215. PM3_WRITE_REG(0x5a00, 1 << 14); /* black magic... */
  1216. tempmisc = PM3RD_MiscControl_VSB_OUTPUT_ENABLE;
  1217. }
  1218. else
  1219. PM3_WRITE_DAC_REG(PM3RD_DACControl, 0x00);
  1221. switch (l_fb_info->current_par->depth) {
  1222. case 8:
  1223. PM3_WRITE_DAC_REG(PM3RD_PixelSize,
  1224.   PM3RD_PixelSize_8_BIT_PIXELS);
  1225. PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
  1226.   PM3RD_ColorFormat_CI8_COLOR |
  1227.   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW);
  1228. tempmisc |= PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
  1229. break;
  1230. case 12:
  1231. PM3_WRITE_DAC_REG(PM3RD_PixelSize,
  1232.   PM3RD_PixelSize_16_BIT_PIXELS);
  1233. PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
  1234.   PM3RD_ColorFormat_4444_COLOR |
  1235.   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW |
  1236.   PM3RD_ColorFormat_LINEAR_COLOR_EXT_ENABLE);
  1237. tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
  1238. PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
  1239. break;
  1240. case 15:
  1241. PM3_WRITE_DAC_REG(PM3RD_PixelSize,
  1242.   PM3RD_PixelSize_16_BIT_PIXELS);
  1243. PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
  1244.   PM3RD_ColorFormat_5551_FRONT_COLOR |
  1245.   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW |
  1246.   PM3RD_ColorFormat_LINEAR_COLOR_EXT_ENABLE);
  1247. tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
  1248. PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
  1249. break;
  1250. case 16:
  1251. PM3_WRITE_DAC_REG(PM3RD_PixelSize,
  1252.   PM3RD_PixelSize_16_BIT_PIXELS);
  1253. PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
  1254.   PM3RD_ColorFormat_565_FRONT_COLOR |
  1255.   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW |
  1256.   PM3RD_ColorFormat_LINEAR_COLOR_EXT_ENABLE);
  1257. tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
  1258. PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
  1259. break;
  1260. case 32:
  1261. PM3_WRITE_DAC_REG(PM3RD_PixelSize,
  1262.   PM3RD_PixelSize_32_BIT_PIXELS);
  1263. PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
  1264.   PM3RD_ColorFormat_8888_COLOR |
  1265.   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW);
  1266. tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
  1267. PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
  1268. break;
  1269. }
  1270. PM3_WRITE_DAC_REG(PM3RD_MiscControl, tempmisc);
  1272. PM3_SHOW_CUR_MODE;
  1273. }
  1275. static void pm3fb_read_mode(struct pm3fb_info *l_fb_info,
  1276.     struct pm3fb_par *curpar)
  1277. {
  1278. unsigned long pixsize1, pixsize2, clockused;
  1279. unsigned long pre, feedback, post;
  1281. DTRACE;
  1283. clockused = PM3_READ_REG(PM3VClkCtl);
  1285. switch (clockused) {
  1286. case 3:
  1287. pre = PM3_READ_DAC_REG(PM3RD_DClk3PreScale);
  1288. feedback = PM3_READ_DAC_REG(PM3RD_DClk3FeedbackScale);
  1289. post = PM3_READ_DAC_REG(PM3RD_DClk3PostScale);
  1291. DPRINTK(2,
  1292. "DClk3 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ldn",
  1293. pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
  1294. feedback,
  1295. post));
  1296. break;
  1297. case 2:
  1298. pre = PM3_READ_DAC_REG(PM3RD_DClk2PreScale);
  1299. feedback = PM3_READ_DAC_REG(PM3RD_DClk2FeedbackScale);
  1300. post = PM3_READ_DAC_REG(PM3RD_DClk2PostScale);
  1302. DPRINTK(2,
  1303. "DClk2 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ldn",
  1304. pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
  1305. feedback,
  1306. post));
  1307. break;
  1308. case 1:
  1309. pre = PM3_READ_DAC_REG(PM3RD_DClk1PreScale);
  1310. feedback = PM3_READ_DAC_REG(PM3RD_DClk1FeedbackScale);
  1311. post = PM3_READ_DAC_REG(PM3RD_DClk1PostScale);
  1313. DPRINTK(2,
  1314. "DClk1 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ldn",
  1315. pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
  1316. feedback,
  1317. post));
  1318. break;
  1319. case 0:
  1320. pre = PM3_READ_DAC_REG(PM3RD_DClk0PreScale);
  1321. feedback = PM3_READ_DAC_REG(PM3RD_DClk0FeedbackScale);
  1322. post = PM3_READ_DAC_REG(PM3RD_DClk0PostScale);
  1324. DPRINTK(2,
  1325. "DClk0 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ldn",
  1326. pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
  1327. feedback,
  1328. post));
  1329. break;
  1330. default:
  1331. pre = feedback = post = 0;
  1332. DPRINTK(1, "Unknowk D clock used : %ldn", clockused);
  1333. break;
  1334. }
  1336. curpar->pixclock = PM3_SCALE_TO_CLOCK(pre, feedback, post);
  1338. pixsize1 =
  1339.     PM3ByApertureMode_PIXELSIZE_MASK &
  1340.     (PM3_READ_REG(PM3ByAperture1Mode));
  1341. pixsize2 =
  1342.     PM3ByApertureMode_PIXELSIZE_MASK &
  1343.     (PM3_READ_REG(PM3ByAperture2Mode));
  1345. DASSERT((pixsize1 == pixsize2),
  1346. "pixsize the same in both aperturen");
  1348. if (pixsize1 & PM3ByApertureMode_PIXELSIZE_32BIT)
  1349. curpar->depth = 32;
  1350. else if (pixsize1 & PM3ByApertureMode_PIXELSIZE_16BIT)
  1351. {
  1352. curpar->depth = 16;
  1353. }
  1354. else
  1355. curpar->depth = 8;
  1357. /* not sure if I need to add one on the next ; it give better result with */
  1358. curpar->htotal =
  1359.     pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
  1360.      1 + PM3_READ_REG(PM3HTotal));
  1361. curpar->hsend =
  1362.     pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
  1363.      PM3_READ_REG(PM3HsEnd));
  1364. curpar->hsstart =
  1365.     pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
  1366.      PM3_READ_REG(PM3HsStart));
  1367. curpar->hbend =
  1368.     pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
  1369.      PM3_READ_REG(PM3HbEnd));
  1371. curpar->stride =
  1372.     pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
  1373.      PM3_READ_REG(PM3ScreenStride));
  1375. curpar->vtotal = 1 + PM3_READ_REG(PM3VTotal);
  1376. curpar->vsend = 1 + PM3_READ_REG(PM3VsEnd);
  1377. curpar->vsstart = 1 + PM3_READ_REG(PM3VsStart);
  1378. curpar->vbend = PM3_READ_REG(PM3VbEnd);
  1380. curpar->video = PM3_READ_REG(PM3VideoControl);
  1382. curpar->base = PM3_READ_REG(PM3ScreenBase);
  1383. curpar->width = curpar->htotal - curpar->hbend; /* make virtual == displayed resolution */
  1384. curpar->height = curpar->vtotal - curpar->vbend;
  1386. DPRINTK(2, "Found : %d * %d, %d Khz, stride is %08xn",
  1387. curpar->width, curpar->height, curpar->pixclock,
  1388. curpar->stride);
  1389. }
  1391. static unsigned long pm3fb_size_memory(struct pm3fb_info *l_fb_info)
  1392. {
  1393. unsigned long memsize = 0, tempBypass, i, temp1, temp2;
  1394. u16 subvendor, subdevice;
  1395. pm3fb_timing_result ptr;
  1397. DTRACE;
  1399. l_fb_info->fb_size = 64 * 1024 * 1024; /* pm3 aperture always 64 MB */
  1400. pm3fb_mapIO(l_fb_info); /* temporary map IO */
  1402. DASSERT((l_fb_info->vIOBase != NULL),
  1403. "IO successfully mapped before mem detectn");
  1404. DASSERT((l_fb_info->v_fb != NULL),
  1405. "FB successfully mapped before mem detectn");
  1407. /* card-specific stuff, *before* accessing *any* FB memory */
  1408. if ((!pci_read_config_word
  1409.      (l_fb_info->dev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor))
  1410.     &&
  1411.     (!pci_read_config_word
  1412.      (l_fb_info->dev, PCI_SUBSYSTEM_ID, &subdevice))) {
  1413. i = 0; l_fb_info->board_type = 0;
  1414. while ((cardbase[i].cardname[0]) && !(l_fb_info->board_type)) {
  1415. if ((cardbase[i].subvendor == subvendor) &&
  1416.     (cardbase[i].subdevice == subdevice) &&
  1417.     (cardbase[i].func == PCI_FUNC(l_fb_info->dev->devfn))) {
  1418. DPRINTK(2, "Card #%ld is an %sn",
  1419. l_fb_info->board_num,
  1420. cardbase[i].cardname);
  1421. if (cardbase[i].specific_setup)
  1422. cardbase[i].specific_setup(l_fb_info);
  1423. l_fb_info->board_type = i;
  1424. }
  1425. i++;
  1426. }
  1427. if (!l_fb_info->board_type) {
  1428. DPRINTK(1, "Card #%ld is an unknown 0x%04x / 0x%04xn",
  1429. l_fb_info->board_num, subvendor, subdevice);
  1430. }
  1431. } else {
  1432. printk(KERN_ERR "pm3fb: Error: pci_read_config_word failed, board #%ldn",
  1433.        l_fb_info->board_num);
  1434. }
  1436. if (printtimings)
  1437. pm3fb_show_cur_timing(l_fb_info);
  1439. /* card-specific setup is done, we preserve the final
  1440.            memory timing for future reference */
  1441. if ((ptr = pm3fb_preserve_memory_timings(l_fb_info)) == pm3fb_timing_problem) { /* memory timings were wrong ! oops.... */
  1442. return(0);
  1443. }
  1445. tempBypass = PM3_READ_REG(PM3MemBypassWriteMask);
  1447. DPRINTK(2, "PM3MemBypassWriteMask was: 0x%08lxn", tempBypass);
  1449. PM3_SLOW_WRITE_REG(PM3MemBypassWriteMask, 0xFFFFFFFF);
  1451. /* pm3 split up memory, replicates, and do a lot of nasty stuff IMHO ;-) */
  1452. for (i = 0; i < 32; i++) {
  1453. #ifdef KERNEL_2_2
  1454. #ifdef MUST_BYTESWAP
  1455. writel(__swab32(i * 0x00345678),
  1456.        (l_fb_info->v_fb + (i * 1048576)));
  1457. #else
  1458. writel(i * 0x00345678, (l_fb_info->v_fb + (i * 1048576)));
  1459. #endif
  1460. mb();
  1461. #ifdef MUST_BYTESWAP
  1462. temp1 = __swab32(readl((l_fb_info->v_fb + (i * 1048576))));
  1463. #else
  1464. temp1 = readl((l_fb_info->v_fb + (i * 1048576)));
  1465. #endif
  1466. #endif /* KERNEL_2_2 */
  1467. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  1468. fb_writel(i * 0x00345678,
  1469.   (l_fb_info->v_fb + (i * 1048576)));
  1470. mb();
  1471. temp1 = fb_readl((l_fb_info->v_fb + (i * 1048576)));
  1472. #endif /* KERNEL_2_4 or KERNEL_2_5 */
  1473. /* Let's check for wrapover, write will fail at 16MB boundary */
  1474. if (temp1 == (i * 0x00345678))
  1475. memsize = i;
  1476. else
  1477. break;
  1478. }
  1480. DPRINTK(2, "First detect pass already got %ld MBn", memsize + 1);
  1482. if (memsize == i) {
  1483. for (i = 0; i < 32; i++) {
  1484. /* Clear first 32MB ; 0 is 0, no need to byteswap */
  1485. writel(0x0000000,
  1486.        (l_fb_info->v_fb + (i * 1048576)));
  1487. mb();
  1488. }
  1490. for (i = 32; i < 64; i++) {
  1491. #ifdef KERNEL_2_2
  1492. #ifdef MUST_BYTESWAP
  1493. writel(__swab32(i * 0x00345678),
  1494.        (l_fb_info->v_fb + (i * 1048576)));
  1495. #else
  1496. writel(i * 0x00345678,
  1497.        (l_fb_info->v_fb + (i * 1048576)));
  1498. #endif
  1499. mb();
  1500. #ifdef MUST_BYTESWAP
  1501. temp1 =
  1502.     __swab32(readl
  1503.      ((l_fb_info->v_fb + (i * 1048576))));
  1504. temp2 =
  1505.     __swab32(readl
  1506.      ((l_fb_info->v_fb +
  1507.        ((i - 32) * 1048576))));
  1508. #else
  1509. temp1 = readl((l_fb_info->v_fb + (i * 1048576)));
  1510. temp2 =
  1511.     readl((l_fb_info->v_fb +
  1512.    ((i - 32) * 1048576)));
  1513. #endif
  1514. #endif /* KERNEL_2_2 */
  1515. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  1516. fb_writel(i * 0x00345678,
  1517.   (l_fb_info->v_fb + (i * 1048576)));
  1518. mb();
  1519. temp1 =
  1520.     fb_readl((l_fb_info->v_fb + (i * 1048576)));
  1521. temp2 =
  1522.     fb_readl((l_fb_info->v_fb +
  1523.       ((i - 32) * 1048576)));
  1524. #endif /* KERNEL_2_4 or KERNEL_2_5 */
  1525. if ((temp1 == (i * 0x00345678)) && (temp2 == 0)) /* different value, different RAM... */
  1526. memsize = i;
  1527. else
  1528. break;
  1529. }
  1530. }
  1532. DPRINTK(2, "Second detect pass got %ld MBn", memsize + 1);
  1534. PM3_SLOW_WRITE_REG(PM3MemBypassWriteMask, tempBypass);
  1536. pm3fb_unmapIO(l_fb_info);
  1537. memsize = 1048576 * (memsize + 1);
  1539. DPRINTK(2, "Returning 0x%08lx bytesn", memsize);
  1541. if (forcesize[l_fb_info->board_num] && ((forcesize[l_fb_info->board_num] * 1048576) != memsize))
  1542. {
  1543. printk(KERN_WARNING "pm3fb: mismatch between probed (%ld MB) and specified (%hd MB) memory size, using SPECIFIED !n", memsize, forcesize[l_fb_info->board_num]);
  1544. memsize = 1048576 * forcesize[l_fb_info->board_num];
  1545. }
  1547. l_fb_info->fb_size = memsize;
  1549. if (ptr == pm3fb_timing_retry)
  1550. {
  1551. printk(KERN_WARNING "pm3fb: retrying memory timings check");
  1552. if (pm3fb_try_memory_timings(l_fb_info) == pm3fb_timing_problem)
  1553. return(0);
  1554. }
  1556. return (memsize);
  1557. }
  1559. static void pm3fb_clear_memory(struct pm3fb_info *l_fb_info, u32 cc)
  1560. {
  1561. int i;
  1563. DTRACE;
  1565. for (i = 0; i < (l_fb_info->fb_size / sizeof(u32)) ; i++) /* clear entire FB memory to black */
  1566. {
  1567. #ifdef KERNEL_2_2
  1568. #ifdef MUST_BYTESWAP
  1569. writel(__swab32(cc), (l_fb_info->v_fb + (i * sizeof(u32))));
  1570. #else
  1571. writel(cc, (l_fb_info->v_fb + (i * sizeof(u32))));
  1572. #endif
  1573. #endif
  1574. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  1575. fb_writel(cc, (l_fb_info->v_fb + (i * sizeof(u32))));
  1576. #endif
  1577. }
  1578. }
  1580. static void pm3fb_clear_colormap(struct pm3fb_info *l_fb_info, unsigned char r, unsigned char g, unsigned char b)
  1581. {
  1582. int i;
  1584. DTRACE;
  1586. for (i = 0; i < 256 ; i++) /* fill color map with white */
  1587. pm3fb_set_color(l_fb_info, i, r, g, b);
  1589. }
  1591. /* common initialisation */
  1592. static void pm3fb_common_init(struct pm3fb_info *l_fb_info)
  1593. {
  1594. DTRACE;
  1596. DPRINTK(2, "Initializing board #%ld @ %lxn", l_fb_info->board_num,
  1597. (unsigned long) l_fb_info);
  1599. strcpy(l_fb_info->gen.info.modename, permedia3_name);
  1600. disp[l_fb_info->board_num].scrollmode = 0; /* SCROLL_YNOMOVE; *//* 0 means "let fbcon choose" */
  1601. l_fb_info->gen.parsize = sizeof(struct pm3fb_par);
  1602. l_fb_info->gen.info.changevar = NULL;
  1603. l_fb_info->gen.info.node = B_FREE;
  1604. l_fb_info->gen.info.fbops = &pm3fb_ops;
  1605. l_fb_info->gen.info.disp = &(disp[l_fb_info->board_num]);
  1606. if (fontn[l_fb_info->board_num][0])
  1607. strcpy(l_fb_info->gen.info.fontname,
  1608.        fontn[l_fb_info->board_num]);
  1609. l_fb_info->gen.info.switch_con = &fbgen_switch;
  1610. l_fb_info->gen.info.updatevar = &fbgen_update_var; /* */
  1611. l_fb_info->gen.info.blank = &fbgen_blank; /* */
  1612. l_fb_info->gen.info.flags = FBINFO_FLAG_DEFAULT;
  1614. pm3fb_mapIO(l_fb_info);
  1616. pm3fb_clear_memory(l_fb_info, 0);
  1617. pm3fb_clear_colormap(l_fb_info, 0, 0, 0);
  1619. (void) fbgen_get_var(&(disp[l_fb_info->board_num]).var, -1,
  1620.      &l_fb_info->gen.info);
  1622. if (depth[l_fb_info->board_num]) /* override mode-defined depth */
  1623. {
  1624. pm3fb_encode_depth(&(disp[l_fb_info->board_num]).var, depth[l_fb_info->board_num]);
  1625. (disp[l_fb_info->board_num]).var.bits_per_pixel = depth2bpp(depth[l_fb_info->board_num]);
  1626. }
  1628. (void) fbgen_do_set_var(&(disp[l_fb_info->board_num]).var, 1,
  1629. &l_fb_info->gen);
  1631. fbgen_set_disp(-1, &l_fb_info->gen);
  1633. fbgen_install_cmap(0, &l_fb_info->gen);
  1635. if (register_framebuffer(&l_fb_info->gen.info) < 0) {
  1636. DPRINTK(1, "Couldn't register framebuffern");
  1637. return;
  1638. }
  1640. PM3_WRITE_DAC_REG(PM3RD_CursorMode,
  1641.   PM3RD_CursorMode_CURSOR_DISABLE);
  1643. PM3_SHOW_CUR_MODE;
  1645. pm3fb_write_mode(l_fb_info);
  1647. printk("fb%d: %s, using %uK of video memory (%s)n",
  1648.        GET_FB_IDX(l_fb_info->gen.info.node),
  1649.        permedia3_name, (u32) (l_fb_info->fb_size >> 10),
  1650.        cardbase[l_fb_info->board_type].cardname);
  1651. }
  1653. /* **************************************************** */
  1654. /* ***** accelerated permedia3-specific functions ***** */
  1655. /* **************************************************** */
  1656. #ifdef PM3FB_USE_ACCEL
  1657. static void pm3fb_wait_pm3(struct pm3fb_info *l_fb_info)
  1658. {
  1659. DTRACE;
  1661. PM3_SLOW_WRITE_REG(PM3FilterMode, PM3FilterModeSync);
  1662. PM3_SLOW_WRITE_REG(PM3Sync, 0);
  1663. mb();
  1664. do {
  1665. while ((PM3_READ_REG(PM3OutFIFOWords)) == 0);
  1666. rmb();
  1667. } while ((PM3_READ_REG(PM3OutputFifo)) != PM3Sync_Tag);
  1668. }
  1670. static void pm3fb_init_engine(struct pm3fb_info *l_fb_info)
  1671. {
  1672. PM3_SLOW_WRITE_REG(PM3FilterMode, PM3FilterModeSync);
  1673. PM3_SLOW_WRITE_REG(PM3StatisticMode, 0x0);
  1674. PM3_SLOW_WRITE_REG(PM3DeltaMode, 0x0);
  1675. PM3_SLOW_WRITE_REG(PM3RasterizerMode, 0x0);
  1676. PM3_SLOW_WRITE_REG(PM3ScissorMode, 0x0);
  1677. PM3_SLOW_WRITE_REG(PM3LineStippleMode, 0x0);
  1678. PM3_SLOW_WRITE_REG(PM3AreaStippleMode, 0x0);
  1679. PM3_SLOW_WRITE_REG(PM3GIDMode, 0x0);
  1680. PM3_SLOW_WRITE_REG(PM3DepthMode, 0x0);
  1681. PM3_SLOW_WRITE_REG(PM3StencilMode, 0x0);
  1682. PM3_SLOW_WRITE_REG(PM3StencilData, 0x0);
  1683. PM3_SLOW_WRITE_REG(PM3ColorDDAMode, 0x0);
  1684. PM3_SLOW_WRITE_REG(PM3TextureCoordMode, 0x0);
  1685. PM3_SLOW_WRITE_REG(PM3TextureIndexMode0, 0x0);
  1686. PM3_SLOW_WRITE_REG(PM3TextureIndexMode1, 0x0);
  1687. PM3_SLOW_WRITE_REG(PM3TextureReadMode, 0x0);
  1688. PM3_SLOW_WRITE_REG(PM3LUTMode, 0x0);
  1689. PM3_SLOW_WRITE_REG(PM3TextureFilterMode, 0x0);
  1690. PM3_SLOW_WRITE_REG(PM3TextureCompositeMode, 0x0);
  1691. PM3_SLOW_WRITE_REG(PM3TextureApplicationMode, 0x0);
  1692. PM3_SLOW_WRITE_REG(PM3TextureCompositeColorMode1, 0x0);
  1693. PM3_SLOW_WRITE_REG(PM3TextureCompositeAlphaMode1, 0x0);
  1694. PM3_SLOW_WRITE_REG(PM3TextureCompositeColorMode0, 0x0);
  1695. PM3_SLOW_WRITE_REG(PM3TextureCompositeAlphaMode0, 0x0);
  1696. PM3_SLOW_WRITE_REG(PM3FogMode, 0x0);
  1697. PM3_SLOW_WRITE_REG(PM3ChromaTestMode, 0x0);
  1698. PM3_SLOW_WRITE_REG(PM3AlphaTestMode, 0x0);
  1699. PM3_SLOW_WRITE_REG(PM3AntialiasMode, 0x0);
  1700. PM3_SLOW_WRITE_REG(PM3YUVMode, 0x0);
  1701. PM3_SLOW_WRITE_REG(PM3AlphaBlendColorMode, 0x0);
  1702. PM3_SLOW_WRITE_REG(PM3AlphaBlendAlphaMode, 0x0);
  1703. PM3_SLOW_WRITE_REG(PM3DitherMode, 0x0);
  1704. PM3_SLOW_WRITE_REG(PM3LogicalOpMode, 0x0);
  1705. PM3_SLOW_WRITE_REG(PM3RouterMode, 0x0);
  1706. PM3_SLOW_WRITE_REG(PM3Window, 0x0);
  1708. PM3_SLOW_WRITE_REG(PM3Config2D, 0x0);
  1710. PM3_SLOW_WRITE_REG(PM3SpanColorMask, 0xffffffff);
  1712. PM3_SLOW_WRITE_REG(PM3XBias, 0x0);
  1713. PM3_SLOW_WRITE_REG(PM3YBias, 0x0);
  1714. PM3_SLOW_WRITE_REG(PM3DeltaControl, 0x0);
  1716. PM3_SLOW_WRITE_REG(PM3BitMaskPattern, 0xffffffff);
  1718. PM3_SLOW_WRITE_REG(PM3FBDestReadEnables,
  1719.    PM3FBDestReadEnables_E(0xff) |
  1720.    PM3FBDestReadEnables_R(0xff) |
  1721.    PM3FBDestReadEnables_ReferenceAlpha(0xff));
  1722. PM3_SLOW_WRITE_REG(PM3FBDestReadBufferAddr0, 0x0);
  1723. PM3_SLOW_WRITE_REG(PM3FBDestReadBufferOffset0, 0x0);
  1724. PM3_SLOW_WRITE_REG(PM3FBDestReadBufferWidth0,
  1725.    PM3FBDestReadBufferWidth_Width(l_fb_info->
  1726.   current_par->
  1727.   width));
  1729. PM3_SLOW_WRITE_REG(PM3FBDestReadMode,
  1730.    PM3FBDestReadMode_ReadEnable |
  1731.    PM3FBDestReadMode_Enable0);
  1732. PM3_SLOW_WRITE_REG(PM3FBSourceReadBufferAddr, 0x0);
  1733. PM3_SLOW_WRITE_REG(PM3FBSourceReadBufferOffset, 0x0);
  1734. PM3_SLOW_WRITE_REG(PM3FBSourceReadBufferWidth,
  1735.    PM3FBSourceReadBufferWidth_Width(l_fb_info->
  1736.     current_par->
  1737.     width));
  1738. PM3_SLOW_WRITE_REG(PM3FBSourceReadMode,
  1739.    PM3FBSourceReadMode_Blocking |
  1740.    PM3FBSourceReadMode_ReadEnable);
  1742. {
  1743. unsigned long rm = 1;
  1744. switch (l_fb_info->current_par->depth) {
  1745. case 8:
  1746. PM3_SLOW_WRITE_REG(PM3PixelSize,
  1747.    PM3PixelSize_GLOBAL_8BIT);
  1748. break;
  1749. case 12:
  1750. case 15:
  1751. case 16:
  1752. PM3_SLOW_WRITE_REG(PM3PixelSize,
  1753.    PM3PixelSize_GLOBAL_16BIT);
  1754. break;
  1755. case 32:
  1756. PM3_SLOW_WRITE_REG(PM3PixelSize,
  1757.    PM3PixelSize_GLOBAL_32BIT);
  1758. break;
  1759. default:
  1760. DPRINTK(1, "Unsupported depth %dn",
  1761. l_fb_info->current_par->depth);
  1762. break;
  1763. }
  1764. PM3_SLOW_WRITE_REG(PM3RasterizerMode, rm);
  1765. }
  1767. PM3_SLOW_WRITE_REG(PM3FBSoftwareWriteMask, 0xffffffff);
  1768. PM3_SLOW_WRITE_REG(PM3FBHardwareWriteMask, 0xffffffff);
  1769. PM3_SLOW_WRITE_REG(PM3FBWriteMode,
  1770.    PM3FBWriteMode_WriteEnable |
  1771.    PM3FBWriteMode_OpaqueSpan |
  1772.    PM3FBWriteMode_Enable0);
  1773. PM3_SLOW_WRITE_REG(PM3FBWriteBufferAddr0, 0x0);
  1774. PM3_SLOW_WRITE_REG(PM3FBWriteBufferOffset0, 0x0);
  1775. PM3_SLOW_WRITE_REG(PM3FBWriteBufferWidth0,
  1776.    PM3FBWriteBufferWidth_Width(l_fb_info->
  1777.        current_par->
  1778.        width));
  1780. PM3_SLOW_WRITE_REG(PM3SizeOfFramebuffer, 0x0);
  1781. {
  1782. unsigned long sofb = (8UL * l_fb_info->fb_size) /
  1783. ((depth2bpp(l_fb_info->current_par->depth))
  1784.  * l_fb_info->current_par->width); /* size in lines of FB */
  1785. if (sofb > 4095)
  1786. PM3_SLOW_WRITE_REG(PM3SizeOfFramebuffer, 4095);
  1787. else
  1788. PM3_SLOW_WRITE_REG(PM3SizeOfFramebuffer, sofb);
  1790. switch (l_fb_info->current_par->depth) {
  1791. case 8:
  1792. PM3_SLOW_WRITE_REG(PM3DitherMode,
  1793.    (1 << 10) | (2 << 3));
  1794. break;
  1795. case 12:
  1796. case 15:
  1797. case 16:
  1798. PM3_SLOW_WRITE_REG(PM3DitherMode,
  1799.    (1 << 10) | (1 << 3));
  1800. break;
  1801. case 32:
  1802. PM3_SLOW_WRITE_REG(PM3DitherMode,
  1803.    (1 << 10) | (0 << 3));
  1804. break;
  1805. default:
  1806. DPRINTK(1, "Unsupported depth %dn",
  1807. l_fb_info->current_par->depth);
  1808. break;
  1809. }
  1810. }
  1812. PM3_SLOW_WRITE_REG(PM3dXDom, 0x0);
  1813. PM3_SLOW_WRITE_REG(PM3dXSub, 0x0);
  1814. PM3_SLOW_WRITE_REG(PM3dY, (1 << 16));
  1815. PM3_SLOW_WRITE_REG(PM3StartXDom, 0x0);
  1816. PM3_SLOW_WRITE_REG(PM3StartXSub, 0x0);
  1817. PM3_SLOW_WRITE_REG(PM3StartY, 0x0);
  1818. PM3_SLOW_WRITE_REG(PM3Count, 0x0);
  1820. /* Disable LocalBuffer. better safe than sorry */
  1821. PM3_SLOW_WRITE_REG(PM3LBDestReadMode, 0x0);
  1822. PM3_SLOW_WRITE_REG(PM3LBDestReadEnables, 0x0);
  1823. PM3_SLOW_WRITE_REG(PM3LBSourceReadMode, 0x0);
  1824. PM3_SLOW_WRITE_REG(PM3LBWriteMode, 0x0);
  1826. pm3fb_wait_pm3(l_fb_info);
  1827. }
  1829. #ifdef FBCON_HAS_CFB32
  1830. static void pm3fb_cfb32_clear(struct vc_data *conp,
  1831.       struct display *p,
  1832.       int sy, int sx, int height, int width)
  1833. {
  1834. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  1835. u32 c;
  1837. DTRACE;
  1839. sx = sx * fontwidth(p);
  1840. width = width * fontwidth(p);
  1841. sy = sy * fontheight(p);
  1842. height = height * fontheight(p);
  1843. c = ((u32 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
  1845. /* block fills in 32bpp are hard, but in low res (width <= 1600 :-)
  1846.    we can use 16bpp operations, but not if NoWriteMask is on (SDRAM)  */
  1847. if ((l_fb_info->current_par->width > 1600) ||
  1848.     (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)) {
  1849. PM3_WAIT(4);
  1851. PM3_WRITE_REG(PM3Config2D,
  1852.   PM3Config2D_UseConstantSource |
  1853.   PM3Config2D_ForegroundROPEnable |
  1854.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  1855.   PM3Config2D_FBWriteEnable);
  1857. PM3_WRITE_REG(PM3ForegroundColor, c);
  1859. PM3_WRITE_REG(PM3RectanglePosition,
  1860.       (PM3RectanglePosition_XOffset(sx)) |
  1861.       (PM3RectanglePosition_YOffset(sy)));
  1863. PM3_WRITE_REG(PM3Render2D,
  1864.       PM3Render2D_XPositive |
  1865.       PM3Render2D_YPositive |
  1866.       PM3Render2D_Operation_Normal |
  1867.       PM3Render2D_SpanOperation |
  1868.       (PM3Render2D_Width(width)) |
  1869.       (PM3Render2D_Height(height)));
  1870. } else {
  1871. PM3_WAIT(8);
  1873. PM3_WRITE_REG(PM3FBBlockColor, c);
  1875. PM3_WRITE_REG(PM3PixelSize, PM3PixelSize_GLOBAL_16BIT);
  1877. PM3_WRITE_REG(PM3FBWriteBufferWidth0,
  1878.       PM3FBWriteBufferWidth_Width(l_fb_info->
  1879.   current_par->
  1880.   width << 1));
  1882. PM3_WRITE_REG(PM3Config2D,
  1883.   PM3Config2D_UseConstantSource |
  1884.   PM3Config2D_ForegroundROPEnable |
  1885.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  1886.   PM3Config2D_FBWriteEnable);
  1888. PM3_WRITE_REG(PM3RectanglePosition,
  1889.       (PM3RectanglePosition_XOffset(sx << 1)) |
  1890.       (PM3RectanglePosition_YOffset(sy)));
  1892. PM3_WRITE_REG(PM3Render2D,
  1893.       PM3Render2D_XPositive |
  1894.       PM3Render2D_YPositive |
  1895.       PM3Render2D_Operation_Normal |
  1896.       (PM3Render2D_Width(width << 1)) |
  1897.       (PM3Render2D_Height(height)));
  1899. PM3_WRITE_REG(PM3FBWriteBufferWidth0,
  1900.       PM3FBWriteBufferWidth_Width(l_fb_info->
  1901.   current_par->
  1902.   width));
  1904. PM3_WRITE_REG(PM3PixelSize, PM3PixelSize_GLOBAL_32BIT);
  1905. }
  1907. pm3fb_wait_pm3(l_fb_info);
  1908. }
  1910. static void pm3fb_cfb32_clear_margins(struct vc_data *conp,
  1911.       struct display *p, int bottom_only)
  1912. {
  1913. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  1914. int sx, sy;
  1915. u32 c;
  1917. DTRACE;
  1919. sx = conp->vc_cols * fontwidth(p); /* right margin */
  1920. sy = conp->vc_rows * fontheight(p); /* bottom margin */
  1921. c = ((u32 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
  1923. if (!bottom_only) { /* right margin top->bottom */
  1924. PM3_WAIT(4);
  1926. PM3_WRITE_REG(PM3Config2D,
  1927.   PM3Config2D_UseConstantSource |
  1928.   PM3Config2D_ForegroundROPEnable |
  1929.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  1930.   PM3Config2D_FBWriteEnable);
  1932. PM3_WRITE_REG(PM3ForegroundColor, c);
  1934. PM3_WRITE_REG(PM3RectanglePosition,
  1935.       (PM3RectanglePosition_XOffset
  1936.        (p->var.xoffset +
  1937. sx)) | (PM3RectanglePosition_YOffset(p->
  1938.      var.
  1939.      yoffset)));
  1941. PM3_WRITE_REG(PM3Render2D,
  1942.       PM3Render2D_XPositive |
  1943.       PM3Render2D_YPositive |
  1944.       PM3Render2D_Operation_Normal |
  1945.       PM3Render2D_SpanOperation |
  1946.       (PM3Render2D_Width(p->var.xres - sx)) |
  1947.       (PM3Render2D_Height(p->var.yres)));
  1948. }
  1950. /* bottom margin left -> right */
  1951. PM3_WAIT(4);
  1953. PM3_WRITE_REG(PM3Config2D,
  1954.   PM3Config2D_UseConstantSource |
  1955.   PM3Config2D_ForegroundROPEnable |
  1956.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  1957.   PM3Config2D_FBWriteEnable);
  1959. PM3_WRITE_REG(PM3ForegroundColor, c);
  1961. PM3_WRITE_REG(PM3RectanglePosition,
  1962.       (PM3RectanglePosition_XOffset(p->var.xoffset)) |
  1963.       (PM3RectanglePosition_YOffset(p->var.yoffset + sy)));
  1965. PM3_WRITE_REG(PM3Render2D,
  1966.       PM3Render2D_XPositive |
  1967.       PM3Render2D_YPositive |
  1968.       PM3Render2D_Operation_Normal |
  1969.       PM3Render2D_SpanOperation |
  1970.       (PM3Render2D_Width(p->var.xres)) |
  1971.       (PM3Render2D_Height(p->var.yres - sy)));
  1973. pm3fb_wait_pm3(l_fb_info);
  1974. }
  1975. #endif /* FBCON_HAS_CFB32 */
  1976. #ifdef FBCON_HAS_CFB16
  1977. static void pm3fb_cfb16_clear(struct vc_data *conp,
  1978.       struct display *p,
  1979.       int sy, int sx, int height, int width)
  1980. {
  1981. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  1982. u32 c;
  1984. DTRACE;
  1986. sx = sx * fontwidth(p);
  1987. width = width * fontwidth(p);
  1988. sy = sy * fontheight(p);
  1989. height = height * fontheight(p);
  1990. c = ((u16 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
  1991. c = c | (c << 16);
  1993. PM3_WAIT(4);
  1995. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  1996. PM3_WRITE_REG(PM3ForegroundColor, c);
  1997. else
  1998. PM3_WRITE_REG(PM3FBBlockColor, c);
  2000. PM3_WRITE_REG(PM3Config2D,
  2001.   PM3Config2D_UseConstantSource |
  2002.   PM3Config2D_ForegroundROPEnable |
  2003.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2004.   PM3Config2D_FBWriteEnable);
  2006. PM3_WRITE_REG(PM3RectanglePosition,
  2007.       (PM3RectanglePosition_XOffset(sx)) |
  2008.       (PM3RectanglePosition_YOffset(sy)));
  2010. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  2011. PM3_WRITE_REG(PM3Render2D,
  2012.       PM3Render2D_XPositive |
  2013.       PM3Render2D_YPositive |
  2014.       PM3Render2D_Operation_Normal |
  2015.       PM3Render2D_SpanOperation |
  2016.       (PM3Render2D_Width(width)) |
  2017.       (PM3Render2D_Height(height)));
  2018. else
  2019. PM3_WRITE_REG(PM3Render2D,
  2020.       PM3Render2D_XPositive |
  2021.       PM3Render2D_YPositive |
  2022.       PM3Render2D_Operation_Normal |
  2023.       (PM3Render2D_Width(width)) |
  2024.       (PM3Render2D_Height(height)));
  2026. pm3fb_wait_pm3(l_fb_info);
  2027. }
  2029. static void pm3fb_cfb16_clear_margins(struct vc_data *conp,
  2030.       struct display *p, int bottom_only)
  2031. {
  2032. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  2033. int sx, sy;
  2034. u32 c;
  2036. DTRACE;
  2038. sx = conp->vc_cols * fontwidth(p); /* right margin */
  2039. sy = conp->vc_rows * fontheight(p); /* bottom margin */
  2040. c = ((u16 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
  2041. c = c | (c << 16);
  2043. if (!bottom_only) { /* right margin top->bottom */
  2044. PM3_WAIT(4);
  2046. PM3_WRITE_REG(PM3Config2D,
  2047.   PM3Config2D_UseConstantSource |
  2048.   PM3Config2D_ForegroundROPEnable |
  2049.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2050.   PM3Config2D_FBWriteEnable);
  2052. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  2053. PM3_WRITE_REG(PM3ForegroundColor, c);
  2054. else
  2055. PM3_WRITE_REG(PM3FBBlockColor, c);
  2057. PM3_WRITE_REG(PM3RectanglePosition,
  2058.       (PM3RectanglePosition_XOffset
  2059.        (p->var.xoffset +
  2060. sx)) | (PM3RectanglePosition_YOffset(p->
  2061.      var.
  2062.      yoffset)));
  2063. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  2064. PM3_WRITE_REG(PM3Render2D,
  2065.       PM3Render2D_XPositive |
  2066.       PM3Render2D_YPositive |
  2067.       PM3Render2D_Operation_Normal |
  2068.       PM3Render2D_SpanOperation |
  2069.       (PM3Render2D_Width(p->var.xres - sx)) |
  2070.       (PM3Render2D_Height(p->var.yres)));
  2071. else
  2072. PM3_WRITE_REG(PM3Render2D,
  2073.       PM3Render2D_XPositive |
  2074.       PM3Render2D_YPositive |
  2075.       PM3Render2D_Operation_Normal |
  2076.       (PM3Render2D_Width(p->var.xres - sx)) |
  2077.       (PM3Render2D_Height(p->var.yres)));
  2078. }
  2080. /* bottom margin left -> right */
  2081. PM3_WAIT(4);
  2083. PM3_WRITE_REG(PM3Config2D,
  2084.       PM3Config2D_UseConstantSource |
  2085.       PM3Config2D_ForegroundROPEnable |
  2086.       (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2087.       PM3Config2D_FBWriteEnable);
  2089. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  2090. PM3_WRITE_REG(PM3ForegroundColor, c);
  2091. else
  2092. PM3_WRITE_REG(PM3FBBlockColor, c);
  2095. PM3_WRITE_REG(PM3RectanglePosition,
  2096.       (PM3RectanglePosition_XOffset(p->var.xoffset)) |
  2097.       (PM3RectanglePosition_YOffset(p->var.yoffset + sy)));
  2099. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  2100. PM3_WRITE_REG(PM3Render2D,
  2101.       PM3Render2D_XPositive |
  2102.       PM3Render2D_YPositive |
  2103.       PM3Render2D_Operation_Normal |
  2104.       PM3Render2D_SpanOperation |
  2105.       (PM3Render2D_Width(p->var.xres)) |
  2106.       (PM3Render2D_Height(p->var.yres - sy)));
  2107. else
  2108. PM3_WRITE_REG(PM3Render2D,
  2109.       PM3Render2D_XPositive |
  2110.       PM3Render2D_YPositive |
  2111.       PM3Render2D_Operation_Normal |
  2112.       (PM3Render2D_Width(p->var.xres)) |
  2113.       (PM3Render2D_Height(p->var.yres - sy)));
  2115. pm3fb_wait_pm3(l_fb_info);
  2116. }
  2117. #endif /* FBCON_HAS_CFB16 */
  2118. #ifdef FBCON_HAS_CFB8
  2119. static void pm3fb_cfb8_clear(struct vc_data *conp,
  2120.      struct display *p,
  2121.      int sy, int sx, int height, int width)
  2122. {
  2123. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  2124. u32 c;
  2126. DTRACE;
  2128. sx = sx * fontwidth(p);
  2129. width = width * fontwidth(p);
  2130. sy = sy * fontheight(p);
  2131. height = height * fontheight(p);
  2133. c = attr_bgcol_ec(p, conp);
  2134. c |= c << 8;
  2135. c |= c << 16;
  2137. PM3_WAIT(4);
  2139. PM3_WRITE_REG(PM3Config2D,
  2140.   PM3Config2D_UseConstantSource |
  2141.   PM3Config2D_ForegroundROPEnable |
  2142.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2143.   PM3Config2D_FBWriteEnable);
  2145. PM3_WRITE_REG(PM3ForegroundColor, c);
  2147. PM3_WRITE_REG(PM3RectanglePosition,
  2148.       (PM3RectanglePosition_XOffset(sx)) |
  2149.       (PM3RectanglePosition_YOffset(sy)));
  2151. PM3_WRITE_REG(PM3Render2D,
  2152.       PM3Render2D_XPositive |
  2153.       PM3Render2D_YPositive |
  2154.       PM3Render2D_Operation_Normal |
  2155.       PM3Render2D_SpanOperation |
  2156.       (PM3Render2D_Width(width)) |
  2157.       (PM3Render2D_Height(height)));
  2159. pm3fb_wait_pm3(l_fb_info);
  2160. }
  2162. static void pm3fb_cfb8_clear_margins(struct vc_data *conp,
  2163.      struct display *p, int bottom_only)
  2164. {
  2165. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  2166. int sx, sy;
  2167. u32 c;
  2169. DTRACE;
  2171. sx = conp->vc_cols * fontwidth(p); /* right margin */
  2172. sy = conp->vc_rows * fontheight(p); /* bottom margin */
  2173. c = attr_bgcol_ec(p, conp);
  2174. c |= c << 8;
  2175. c |= c << 16;
  2177. if (!bottom_only) { /* right margin top->bottom */
  2178. PM3_WAIT(4);
  2180. PM3_WRITE_REG(PM3Config2D,
  2181.   PM3Config2D_UseConstantSource |
  2182.   PM3Config2D_ForegroundROPEnable |
  2183.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2184.   PM3Config2D_FBWriteEnable);
  2186. PM3_WRITE_REG(PM3ForegroundColor, c);
  2188. PM3_WRITE_REG(PM3RectanglePosition,
  2189.       (PM3RectanglePosition_XOffset
  2190.        (p->var.xoffset +
  2191. sx)) | (PM3RectanglePosition_YOffset(p->
  2192.      var.
  2193.      yoffset)));
  2195. PM3_WRITE_REG(PM3Render2D,
  2196.       PM3Render2D_XPositive |
  2197.       PM3Render2D_YPositive |
  2198.       PM3Render2D_Operation_Normal |
  2199.       PM3Render2D_SpanOperation |
  2200.       (PM3Render2D_Width(p->var.xres - sx)) |
  2201.       (PM3Render2D_Height(p->var.yres)));
  2202. }
  2204. /* bottom margin left -> right */
  2205. PM3_WAIT(4);
  2207. PM3_WRITE_REG(PM3Config2D,
  2208.   PM3Config2D_UseConstantSource |
  2209.   PM3Config2D_ForegroundROPEnable |
  2210.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2211.   PM3Config2D_FBWriteEnable);
  2213. PM3_WRITE_REG(PM3ForegroundColor, c);
  2215. PM3_WRITE_REG(PM3RectanglePosition,
  2216.       (PM3RectanglePosition_XOffset(p->var.xoffset)) |
  2217.       (PM3RectanglePosition_YOffset(p->var.yoffset + sy)));
  2219. PM3_WRITE_REG(PM3Render2D,
  2220.       PM3Render2D_XPositive |
  2221.       PM3Render2D_YPositive |
  2222.       PM3Render2D_Operation_Normal |
  2223.       PM3Render2D_SpanOperation |
  2224.       (PM3Render2D_Width(p->var.xres)) |
  2225.       (PM3Render2D_Height(p->var.yres - sy)));
  2227. pm3fb_wait_pm3(l_fb_info);
  2228. }
  2229. #endif /* FBCON_HAS_CFB8 */
  2230. #if defined(FBCON_HAS_CFB8) || defined(FBCON_HAS_CFB16) || defined(FBCON_HAS_CFB32)
  2231. static void pm3fb_cfbX_bmove(struct display *p,
  2232.      int sy, int sx,
  2233.      int dy, int dx, int height, int width)
  2234. {
  2235. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  2236. int x_align, o_x, o_y;
  2238. DTRACE;
  2240. sx = sx * fontwidth(p);
  2241. dx = dx * fontwidth(p);
  2242. width = width * fontwidth(p);
  2243. sy = sy * fontheight(p);
  2244. dy = dy * fontheight(p);
  2245. height = height * fontheight(p);
  2247. o_x = sx - dx; /*(sx > dx ) ? (sx - dx) : (dx - sx); */
  2248. o_y = sy - dy; /*(sy > dy ) ? (sy - dy) : (dy - sy); */
  2250. x_align = (sx & 0x1f);
  2252. PM3_WAIT(6);
  2254. PM3_WRITE_REG(PM3Config2D,
  2255.   PM3Config2D_UserScissorEnable |
  2256.   PM3Config2D_ForegroundROPEnable |
  2257.   PM3Config2D_Blocking |
  2258.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2259.   PM3Config2D_FBWriteEnable);
  2261. PM3_WRITE_REG(PM3ScissorMinXY,
  2262.       ((dy & 0x0fff) << 16) | (dx & 0x0fff));
  2263. PM3_WRITE_REG(PM3ScissorMaxXY,
  2264.   (((dy + height) & 0x0fff) << 16) |
  2265.   ((dx + width) & 0x0fff));
  2267. PM3_WRITE_REG(PM3FBSourceReadBufferOffset,
  2268.       PM3FBSourceReadBufferOffset_XOffset(o_x) |
  2269.       PM3FBSourceReadBufferOffset_YOffset(o_y));
  2271. PM3_WRITE_REG(PM3RectanglePosition,
  2272.       (PM3RectanglePosition_XOffset(dx - x_align)) |
  2273.       (PM3RectanglePosition_YOffset(dy)));
  2275. PM3_WRITE_REG(PM3Render2D,
  2276.       ((sx > dx) ? PM3Render2D_XPositive : 0) |
  2277.       ((sy > dy) ? PM3Render2D_YPositive : 0) |
  2278.       PM3Render2D_Operation_Normal |
  2279.       PM3Render2D_SpanOperation |
  2280.       PM3Render2D_FBSourceReadEnable |
  2281.       (PM3Render2D_Width(width + x_align)) |
  2282.       (PM3Render2D_Height(height)));
  2284. pm3fb_wait_pm3(l_fb_info);
  2285. }
  2287. static void pm3fb_cfbX_putc(struct vc_data *conp, struct display *p,
  2288.     int c, int yy, int xx)
  2289. {
  2290. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  2291. u8 *cdat, asx = 0, asy = 0, o_x = 0, o_y = 0;
  2292. u32 fgx, bgx, ldat;
  2293. int sx, sy, i;
  2295. DTRACE;
  2297. if (l_fb_info->current_par->depth == 8)
  2298. fgx = attr_fgcol(p, c);
  2299. else if (depth2bpp(l_fb_info->current_par->depth) == 16)
  2300. fgx = ((u16 *) p->dispsw_data)[attr_fgcol(p, c)];
  2301. else
  2302. fgx = ((u32 *) p->dispsw_data)[attr_fgcol(p, c)];
  2304. PM3_COLOR(fgx);
  2306. if (l_fb_info->current_par->depth == 8)
  2307. bgx = attr_bgcol(p, c);
  2308. else if (depth2bpp(l_fb_info->current_par->depth) == 16)
  2309. bgx = ((u16 *) p->dispsw_data)[attr_bgcol(p, c)];
  2310. else
  2311. bgx = ((u32 *) p->dispsw_data)[attr_bgcol(p, c)];
  2313. PM3_COLOR(bgx);
  2315. PM3_WAIT(4);
  2317. PM3_WRITE_REG(PM3Config2D,
  2318.   PM3Config2D_UseConstantSource |
  2319.   PM3Config2D_ForegroundROPEnable |
  2320.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2321.   PM3Config2D_FBWriteEnable | PM3Config2D_OpaqueSpan);
  2323. PM3_WRITE_REG(PM3ForegroundColor, fgx);
  2324. PM3_WRITE_REG(PM3FillBackgroundColor, bgx);
  2326. /* WARNING : adress select X need to specify 8 bits for fontwidth <= 8 */
  2327. /* and 16 bits for fontwidth <= 16 */
  2328. /* same in _putcs, same for Y and fontheight */
  2329. if (fontwidth(p) <= 8)
  2330. asx = 2;
  2331. else if (fontwidth(p) <= 16)
  2332. asx = 3; /* look OK */
  2333. if (fontheight(p) <= 8)
  2334. asy = 2;
  2335. else if (fontheight(p) <= 16)
  2336. asy = 3; /* look OK */
  2337. else if (fontheight(p) <= 32)
  2338. asy = 4; /* look OK */
  2340. sx = xx * fontwidth(p);
  2341. sy = yy * fontheight(p);
  2343. if (fontwidth(p) <= 8)
  2344. o_x = (8 - (sx & 0x7)) & 0x7;
  2345. else if (fontwidth(p) <= 16)
  2346. o_x = (16 - (sx & 0xF)) & 0xF;
  2347. if (fontheight(p) <= 8)
  2348. o_y = (8 - (sy & 0x7)) & 0x7;
  2349. else if (fontheight(p) <= 16)
  2350. o_y = (16 - (sy & 0xF)) & 0xF;
  2351. else if (fontheight(p) <= 32)
  2352. o_y = (32 - (sy & 0x1F)) & 0x1F;
  2354. PM3_WRITE_REG(PM3AreaStippleMode, (o_x << 7) | (o_y << 12) | /* x_offset, y_offset in pattern */
  2355.       (1 << 18) | /* BE */
  2356.       1 | (asx << 1) | (asy << 4) | /* address select x/y */
  2357.       (1 << 20)); /* OpaqueSpan */
  2359. if (fontwidth(p) <= 8) {
  2360. cdat = p->fontdata + (c & p->charmask) * fontheight(p);
  2361. } else {
  2362. cdat =
  2363.     p->fontdata +
  2364.     ((c & p->charmask) * (fontheight(p) << 1));
  2365. }
  2367. PM3_WAIT(2 + fontheight(p));
  2369. for (i = 0; i < fontheight(p); i++) { /* assume fontheight <= 32 */
  2370. if (fontwidth(p) <= 8) {
  2371. ldat = *cdat++;
  2372. } else { /* assume fontwidth <= 16 ATM */
  2374. ldat = ((*cdat++) << 8);
  2375. ldat |= *cdat++;
  2376. }
  2377. PM3_WRITE_REG(AreaStipplePattern_indexed(i), ldat);
  2378. }
  2380. PM3_WRITE_REG(PM3RectanglePosition,
  2381.       (PM3RectanglePosition_XOffset(sx)) |
  2382.       (PM3RectanglePosition_YOffset(sy)));
  2384. PM3_WRITE_REG(PM3Render2D,
  2385.       PM3Render2D_AreaStippleEnable |
  2386.       PM3Render2D_XPositive |
  2387.       PM3Render2D_YPositive |
  2388.       PM3Render2D_Operation_Normal |
  2389.       PM3Render2D_SpanOperation |
  2390.       (PM3Render2D_Width(fontwidth(p))) |
  2391.       (PM3Render2D_Height(fontheight(p))));
  2393. pm3fb_wait_pm3(l_fb_info);
  2394. }
  2396. static void pm3fb_cfbX_putcs(struct vc_data *conp, struct display *p,
  2397.      const unsigned short *s, int count, int yy,
  2398.      int xx)
  2399. {
  2400. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  2401. u8 *cdat, asx = 0, asy = 0, o_x = 0, o_y = 0;
  2402. u32 fgx, bgx, ldat;
  2403. int sx, sy, i, j;
  2404. u16 sc;
  2406. DTRACE;
  2408. sc = scr_readw(s);
  2409. if (l_fb_info->current_par->depth == 8)
  2410. fgx = attr_fgcol(p, sc);
  2411. else if (depth2bpp(l_fb_info->current_par->depth) == 16)
  2412. fgx = ((u16 *) p->dispsw_data)[attr_fgcol(p, sc)];
  2413. else
  2414. fgx = ((u32 *) p->dispsw_data)[attr_fgcol(p, sc)];
  2416. PM3_COLOR(fgx);
  2418. if (l_fb_info->current_par->depth == 8)
  2419. bgx = attr_bgcol(p, sc);
  2420. else if (depth2bpp(l_fb_info->current_par->depth) == 16)
  2421. bgx = ((u16 *) p->dispsw_data)[attr_bgcol(p, sc)];
  2422. else
  2423. bgx = ((u32 *) p->dispsw_data)[attr_bgcol(p, sc)];
  2425. PM3_COLOR(bgx);
  2427. PM3_WAIT(4);
  2429. PM3_WRITE_REG(PM3Config2D,
  2430.   PM3Config2D_UseConstantSource |
  2431.   PM3Config2D_ForegroundROPEnable |
  2432.   (PM3Config2D_ForegroundROP(0x3)) | /* Ox3 is GXcopy */
  2433.   PM3Config2D_FBWriteEnable |
  2434.   PM3Config2D_OpaqueSpan);
  2436. PM3_WRITE_REG(PM3ForegroundColor, fgx);
  2437. PM3_WRITE_REG(PM3FillBackgroundColor, bgx);
  2439. /* WARNING : adress select X need to specify 8 bits for fontwidth <= 8 */
  2440. /* and 16 bits for fontwidth <= 16 */
  2441. /* same in _putc, same for Y and fontheight */
  2442. if (fontwidth(p) <= 8)
  2443. asx = 2;
  2444. else if (fontwidth(p) <= 16)
  2445. asx = 3; /* look OK */
  2446. if (fontheight(p) <= 8)
  2447. asy = 2;
  2448. else if (fontheight(p) <= 16)
  2449. asy = 3; /* look OK */
  2450. else if (fontheight(p) <= 32)
  2451. asy = 4; /* look OK */
  2453. sy = yy * fontheight(p);
  2455. if (fontheight(p) <= 8)
  2456. o_y = (8 - (sy & 0x7)) & 0x7;
  2457. else if (fontheight(p) <= 16)
  2458. o_y = (16 - (sy & 0xF)) & 0xF;
  2459. else if (fontheight(p) <= 32)
  2460. o_y = (32 - (sy & 0x1F)) & 0x1F;
  2462. for (j = 0; j < count; j++) {
  2463. sc = scr_readw(s + j);
  2464. if (fontwidth(p) <= 8)
  2465. cdat = p->fontdata +
  2466. (sc & p->charmask) * fontheight(p);
  2467. else
  2468. cdat = p->fontdata +
  2469. ((sc & p->charmask) * fontheight(p) << 1);
  2471. sx = (xx + j) * fontwidth(p);
  2473. if (fontwidth(p) <= 8)
  2474. o_x = (8 - (sx & 0x7)) & 0x7;
  2475. else if (fontwidth(p) <= 16)
  2476. o_x = (16 - (sx & 0xF)) & 0xF;
  2478. PM3_WAIT(3 + fontheight(p));
  2480. PM3_WRITE_REG(PM3AreaStippleMode, (o_x << 7) | (o_y << 12) | /* x_offset, y_offset in pattern */
  2481.       (1 << 18) | /* BE */
  2482.       1 | (asx << 1) | (asy << 4) | /* address select x/y */
  2483.       (1 << 20)); /* OpaqueSpan */
  2485. for (i = 0; i < fontheight(p); i++) { /* assume fontheight <= 32 */
  2486. if (fontwidth(p) <= 8) {
  2487. ldat = *cdat++;
  2488. } else { /* assume fontwidth <= 16 ATM */
  2489. ldat = ((*cdat++) << 8);
  2490. ldat |= *cdat++;
  2491. }
  2492. PM3_WRITE_REG(AreaStipplePattern_indexed(i), ldat);
  2493. }
  2495. PM3_WRITE_REG(PM3RectanglePosition,
  2496.       (PM3RectanglePosition_XOffset(sx)) |
  2497.       (PM3RectanglePosition_YOffset(sy)));
  2499. PM3_WRITE_REG(PM3Render2D,
  2500.       PM3Render2D_AreaStippleEnable |
  2501.       PM3Render2D_XPositive |
  2502.       PM3Render2D_YPositive |
  2503.       PM3Render2D_Operation_Normal |
  2504.       PM3Render2D_SpanOperation |
  2505.       (PM3Render2D_Width(fontwidth(p))) |
  2506.       (PM3Render2D_Height(fontheight(p))));
  2507. }
  2508. pm3fb_wait_pm3(l_fb_info);
  2509. }
  2511. static void pm3fb_cfbX_revc(struct display *p, int xx, int yy)
  2512. {
  2513. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
  2515. xx = xx * fontwidth(p);
  2516. yy = yy * fontheight(p);
  2518. if (l_fb_info->current_par->depth == 8)
  2519. {
  2520. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  2521. PM3_SLOW_WRITE_REG(PM3FBSoftwareWriteMask, 0x0F0F0F0F);
  2522. else
  2523. PM3_SLOW_WRITE_REG(PM3FBHardwareWriteMask, 0x0F0F0F0F);
  2524. }
  2526. PM3_WAIT(3);
  2528. PM3_WRITE_REG(PM3Config2D,
  2529.   PM3Config2D_UseConstantSource |
  2530.   PM3Config2D_ForegroundROPEnable |
  2531.   (PM3Config2D_ForegroundROP(0xa)) | /* Oxa is GXinvert */
  2532.   PM3Config2D_FBDestReadEnable |
  2533.   PM3Config2D_FBWriteEnable);
  2535. PM3_WRITE_REG(PM3RectanglePosition,
  2536.       (PM3RectanglePosition_XOffset(xx)) |
  2537.       (PM3RectanglePosition_YOffset(yy)));
  2539. PM3_WRITE_REG(PM3Render2D,
  2540.       PM3Render2D_XPositive |
  2541.       PM3Render2D_YPositive |
  2542.       PM3Render2D_Operation_Normal |
  2543.       PM3Render2D_SpanOperation |
  2544.       (PM3Render2D_Width(fontwidth(p))) |
  2545.       (PM3Render2D_Height(fontheight(p))));
  2547. pm3fb_wait_pm3(l_fb_info);
  2549. if (l_fb_info->current_par->depth == 8)
  2550. {
  2551. if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
  2552. PM3_SLOW_WRITE_REG(PM3FBSoftwareWriteMask, 0xFFFFFFFF);
  2553. else
  2554. PM3_SLOW_WRITE_REG(PM3FBHardwareWriteMask, 0xFFFFFFFF);
  2555. }
  2556. }
  2558. #endif /* FBCON_HAS_CFB8 || FBCON_HAS_CFB16 || FBCON_HAS_CFB32 */
  2559. #endif /* PM3FB_USE_ACCEL */
  2560. /* *********************************** */
  2561. /* ***** pre-init board(s) setup ***** */
  2562. /* *********************************** */
  2564. static void pm3fb_mode_setup(char *mode, unsigned long board_num)
  2565. {
  2566. struct pm3fb_info *l_fb_info = &(fb_info[board_num]);
  2567. struct pm3fb_par *l_fb_par = &(current_par[board_num]);
  2568. unsigned long i = 0;
  2570. current_par_valid[board_num] = 0;
  2572. if (!strncmp(mode, "current", 7)) {
  2573. l_fb_info->use_current = 1; /* default w/ OpenFirmware */
  2574. } else {
  2575. while ((mode_base[i].name[0])
  2576.        && (!current_par_valid[board_num])) {
  2577. if (!
  2578.     (strncmp
  2579.      (mode, mode_base[i].name,
  2580.       strlen(mode_base[i].name)))) {
  2581. memcpy(l_fb_par, &(mode_base[i].user_mode),
  2582.        sizeof(struct pm3fb_par));
  2583. current_par_valid[board_num] = 1;
  2584. DPRINTK(2, "Mode set to %sn",
  2585. mode_base[i].name);
  2586. }
  2587. i++;
  2588. }
  2589. DASSERT(current_par_valid[board_num],
  2590. "Valid mode on command linen");
  2591. }
  2592. }
  2594. static void pm3fb_pciid_setup(char *pciid, unsigned long board_num)
  2595. {
  2596. short l_bus = -1, l_slot = -1, l_func = -1;
  2597. char *next;
  2599. if (pciid) {
  2600. l_bus = simple_strtoul(pciid, &next, 10);
  2601. if (next && (next[0] == ':')) {
  2602. pciid = next + 1;
  2603. l_slot = simple_strtoul(pciid, &next, 10);
  2604. if (next && (next[0] == ':')) {
  2605. pciid = next + 1;
  2606. l_func =
  2607.     simple_strtoul(pciid, (char **) NULL,
  2608.    10);
  2609. }
  2610. }
  2611. } else
  2612. return;
  2614. if ((l_bus >= 0) && (l_slot >= 0) && (l_func >= 0)) {
  2615. bus[board_num] = l_bus;
  2616. slot[board_num] = l_slot;
  2617. func[board_num] = l_func;
  2618. DPRINTK(2, "Board #%ld will be PciId: %hd:%hd:%hdn",
  2619. board_num, l_bus, l_slot, l_func);
  2620. } else {
  2621. DPRINTK(1, "Invalid PciId: %hd:%hd:%hd for board #%ldn",
  2622. l_bus, l_slot, l_func, board_num);
  2623. }
  2624. }
  2626. static void pm3fb_font_setup(char *lf, unsigned long board_num)
  2627. {
  2628. unsigned long lfs = strlen(lf);
  2630. if (lfs > (PM3_FONTNAME_SIZE - 1)) {
  2631. DPRINTK(1, "Fontname %s too longn", lf);
  2632. return;
  2633. }
  2634. strncpy(fontn[board_num], lf, lfs);
  2635. fontn[board_num][lfs] = '';
  2636. }
  2638. static void pm3fb_bootdepth_setup(char *bds, unsigned long board_num)
  2639. {
  2640. unsigned long bd = simple_strtoul(bds, (char **) NULL, 10);
  2642. if (!(depth_supported(bd))) {
  2643. printk(KERN_WARNING "pm3fb: ignoring invalid depth %s for board #%ldn",
  2644.        bds, board_num);
  2645. return;
  2646. }
  2647. depth[board_num] = bd;
  2648. }
  2650. static void pm3fb_forcesize_setup(char *bds, unsigned long board_num)
  2651. {
  2652. unsigned long bd = simple_strtoul(bds, (char **) NULL, 10);
  2654. if (bd > 64) {
  2655. printk(KERN_WARNING "pm3fb: ignoring invalid memory size %s for board #%ldn",
  2656.        bds, board_num);
  2657. return;
  2658. }
  2659. forcesize[board_num] = bd;
  2660. }
  2662. static char *pm3fb_boardnum_setup(char *options, unsigned long *bn)
  2663. {
  2664. char *next;
  2666. if (!(CHAR_IS_NUM(options[0]))) {
  2667. (*bn) = 0;
  2668. return (options);
  2669. }
  2671. (*bn) = simple_strtoul(options, &next, 10);
  2673. if (next && (next[0] == ':') && ((*bn) >= 0)
  2674.     && ((*bn) <= PM3_MAX_BOARD)) {
  2675. DPRINTK(2, "Board_num seen as %ldn", (*bn));
  2676. return (next + 1);
  2677. } else {
  2678. (*bn) = 0;
  2679. DPRINTK(2, "Board_num default to %ldn", (*bn));
  2680. return (options);
  2681. }
  2682. }
  2684. static void pm3fb_real_setup(char *options)
  2685. {
  2686. char *next;
  2687. unsigned long i, bn;
  2688. struct pm3fb_info *l_fb_info;
  2690. DTRACE;
  2692. DPRINTK(2, "Options : %sn", options);
  2694. for (i = 0; i < PM3_MAX_BOARD; i++) {
  2695. l_fb_info = &(fb_info[i]);
  2696. memset(l_fb_info, 0, sizeof(struct pm3fb_info));
  2697. l_fb_info->gen.fbhw = &pm3fb_switch;
  2698. l_fb_info->board_num = i;
  2699. current_par_valid[i] = 0;
  2700. slot[i] = -1;
  2701. func[i] = -1;
  2702. bus[i] = -1;
  2703. disable[i] = 0;
  2704. noaccel[i] = 0;
  2705. fontn[i][0] = '';
  2706. depth[i] = 0;
  2707. l_fb_info->current_par = &(current_par[i]);
  2708. }
  2710. /* eat up prefix pm3fb and whatever is used as separator i.e. :,= */
  2711. if (!strncmp(options, "pm3fb", 5)) {
  2712. options += 5;
  2713. while (((*options) == ',') || ((*options) == ':')
  2714.        || ((*options) == '='))
  2715. options++;
  2716. }
  2718. while (options) {
  2719. bn = 0;
  2720. if ((next = strchr(options, ','))) {
  2721. (*next) = '';
  2722. next++;
  2723. }
  2725. if (!strncmp(options, "mode:", 5)) {
  2726. options = pm3fb_boardnum_setup(options + 5, &bn);
  2727. DPRINTK(2, "Setting mode for board #%ldn", bn);
  2728. pm3fb_mode_setup(options, bn);
  2729. } else if (!strncmp(options, "off:", 4)) {
  2730. options = pm3fb_boardnum_setup(options + 4, &bn);
  2731. DPRINTK(2, "Disabling board #%ldn", bn);
  2732. disable[bn] = 1;
  2733. } else if (!strncmp(options, "off", 3)) { /* disable everything */
  2734. for (i = 0; i < PM3_MAX_BOARD; i++)
  2735. disable[i] = 1;
  2736. } else if (!strncmp(options, "disable:", 8)) {
  2737. options = pm3fb_boardnum_setup(options + 8, &bn);
  2738. DPRINTK(2, "Disabling board #%ldn", bn);
  2739. disable[bn] = 1;
  2740. } else if (!strncmp(options, "pciid:", 6)) {
  2741. options = pm3fb_boardnum_setup(options + 6, &bn);
  2742. DPRINTK(2, "Setting PciID for board #%ldn", bn);
  2743. pm3fb_pciid_setup(options, bn);
  2744. } else if (!strncmp(options, "noaccel:", 8)) {
  2745. options = pm3fb_boardnum_setup(options + 8, &bn);
  2746. noaccel[bn] = 1;
  2747. } else if (!strncmp(options, "font:", 5)) {
  2748. options = pm3fb_boardnum_setup(options + 5, &bn);
  2749. pm3fb_font_setup(options, bn);
  2750. } else if (!strncmp(options, "depth:", 6)) {
  2751. options = pm3fb_boardnum_setup(options + 6, &bn);
  2752. pm3fb_bootdepth_setup(options, bn);
  2753. } else if (!strncmp(options, "printtimings", 12)) {
  2754. printtimings = 1;
  2755. } else if (!strncmp(options, "flatpanel:", 10)) {
  2756. options = pm3fb_boardnum_setup(options + 10, &bn);
  2757. flatpanel[bn] = 1;
  2758. } else if (!strncmp(options, "forcesize:", 10)) {
  2759. options = pm3fb_boardnum_setup(options + 10, &bn);
  2760. pm3fb_forcesize_setup(options, bn);
  2761. }
  2762. options = next;
  2763. }
  2764. }
  2766. /* ********************************************** */
  2767. /* ***** framebuffer API standard functions ***** */
  2768. /* ********************************************** */
  2770. static int pm3fb_open(struct fb_info *info, int user)
  2771. {
  2772. DTRACE;
  2774. MOD_INC_USE_COUNT;
  2776. return (0);
  2777. }
  2779. static int pm3fb_release(struct fb_info *info, int user)
  2780. {
  2781. DTRACE;
  2783. MOD_DEC_USE_COUNT;
  2785. return (0);
  2786. }
  2788. static int pm3fb_encode_fix(struct fb_fix_screeninfo *fix,
  2789.     const void *par, struct fb_info_gen *info)
  2790. {
  2791. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  2792. struct pm3fb_par *p = (struct pm3fb_par *) par;
  2794. DTRACE;
  2796. strcpy(fix->id, permedia3_name);
  2797. fix->smem_start = (unsigned long)l_fb_info->p_fb;
  2798. fix->smem_len = l_fb_info->fb_size;
  2799. fix->mmio_start = (unsigned long)l_fb_info->pIOBase;
  2800. fix->mmio_len = PM3_REGS_SIZE;
  2801. #ifdef PM3FB_USE_ACCEL
  2802. if (!(noaccel[l_fb_info->board_num]))
  2803. fix->accel = FB_ACCEL_3DLABS_PERMEDIA3;
  2804. else
  2805. #endif /* PM3FB_USE_ACCEL */
  2806. fix->accel = FB_ACCEL_NONE;
  2807. fix->type = FB_TYPE_PACKED_PIXELS;
  2808. fix->visual =
  2809.     (p->depth == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
  2810. if (current_par_valid[l_fb_info->board_num])
  2811. fix->line_length =
  2812. l_fb_info->current_par->width *
  2813. depth2ByPP(l_fb_info->current_par->depth);
  2814. else
  2815. fix->line_length = 0;
  2816. fix->xpanstep = 64 / depth2bpp(p->depth);
  2817. fix->ypanstep = 1;
  2818. fix->ywrapstep = 0;
  2819. return (0);
  2820. }
  2822. static int pm3fb_decode_var(const struct fb_var_screeninfo *var,
  2823.     void *par, struct fb_info_gen *info)
  2824. {
  2825. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  2826. struct pm3fb_par *p = (struct pm3fb_par *) par;
  2827. struct pm3fb_par temp_p;
  2828. u32 xres;
  2830. DTRACE;
  2832. DASSERT((var != NULL), "fb_var_screeninfo* not NULL");
  2833. DASSERT((p != NULL), "pm3fb_par* not NULL");
  2834. DASSERT((l_fb_info != NULL), "pm3fb_info* not NULL");
  2836. memset(&temp_p, 0, sizeof(struct pm3fb_par));
  2837. temp_p.width = (var->xres_virtual + 7) & ~7;
  2838. temp_p.height = var->yres_virtual;
  2840. if (!(depth_supported(var->bits_per_pixel))) /* round unsupported up to a multiple of 8 */
  2841. temp_p.depth = depth2bpp(var->bits_per_pixel);
  2842. else
  2843. temp_p.depth = var->bits_per_pixel;
  2845. temp_p.depth = (temp_p.depth > 32) ? 32 : temp_p.depth; /* max 32 */
  2846. temp_p.depth = (temp_p.depth == 24) ? 32 : temp_p.depth; /* 24 unsupported, round-up to 32 */
  2848. if ((temp_p.depth == 16) && (var->red.length == 5) && (var->green.length == 5) && (var->blue.length == 5))
  2849. temp_p.depth = 15; /* RGBA 5551 is stored as depth 15 */
  2851. if ((temp_p.depth == 16) && (var->red.length == 4) && (var->green.length == 4) && (var->blue.length == 4))
  2852. temp_p.depth = 12; /* RGBA 4444  is stored as depth 12 */
  2855. DPRINTK(2,
  2856. "xres: %d, yres: %d, vxres: %d, vyres: %d ; xoffset:%d, yoffset: %dn",
  2857. var->xres, var->yres, var->xres_virtual, var->yres_virtual,
  2858. var->xoffset, var->yoffset);
  2860. xres = (var->xres + 31) & ~31;
  2861. if (temp_p.width < xres + var->xoffset)
  2862. temp_p.width = xres + var->xoffset;
  2863. if (temp_p.height < var->yres + var->yoffset)
  2864. temp_p.height = var->yres + var->yoffset;
  2866. if (temp_p.width > 2048) {
  2867. DPRINTK(1, "virtual width not supported: %un",
  2868. temp_p.width);
  2869. return (-EINVAL);
  2870. }
  2871. if (var->yres < 200) {
  2872. DPRINTK(1, "height not supported: %un", (u32) var->yres);
  2873. return (-EINVAL);
  2874. }
  2875. if (temp_p.height < 200 || temp_p.height > 4095) {
  2876. DPRINTK(1, "virtual height not supported: %un",
  2877. temp_p.height);
  2878. return (-EINVAL);
  2879. }
  2880. if (!(depth_supported(temp_p.depth))) {
  2881. DPRINTK(1, "depth not supported: %un", temp_p.depth);
  2882. return (-EINVAL);
  2883. }
  2884. if ((temp_p.width * temp_p.height * depth2ByPP(temp_p.depth)) >
  2885.     l_fb_info->fb_size) {
  2886. DPRINTK(1, "no memory for screen (%ux%ux%u)n",
  2887. temp_p.width, temp_p.height, temp_p.depth);
  2888. return (-EINVAL);
  2889. }
  2891. if ((!var->pixclock) ||
  2892.     (!var->right_margin) ||
  2893.     (!var->hsync_len) ||
  2894.     (!var->left_margin) ||
  2895.     (!var->lower_margin) ||
  2896.     (!var->vsync_len) || (!var->upper_margin)
  2897.     ) {
  2898. unsigned long i = 0, done = 0;
  2899. printk(KERN_WARNING "pm3fb: refusing to use a likely wrong timingn");
  2901. while ((mode_base[i].user_mode.width) && !done) {
  2902. if ((mode_base[i].user_mode.width == temp_p.width)
  2903.     && (mode_base[i].user_mode.height ==
  2904. temp_p.height)) {
  2905. printk(KERN_NOTICE "pm3fb: using close match %sn",
  2906.        mode_base[i].name);
  2907. temp_p = mode_base[i].user_mode;
  2908. done = 1;
  2909. }
  2910. i++;
  2911. }
  2912. if (!done)
  2913. return (-EINVAL);
  2914. } else {
  2915. temp_p.pixclock = PICOS2KHZ(var->pixclock);
  2916. if (temp_p.pixclock > PM3_MAX_PIXCLOCK) {
  2917. DPRINTK(1, "pixclock too high (%uKHz)n",
  2918. temp_p.pixclock);
  2919. return (-EINVAL);
  2920. }
  2922. temp_p.hsstart = var->right_margin;
  2923. temp_p.hsend = var->right_margin + var->hsync_len;
  2924. temp_p.hbend =
  2925.     var->right_margin + var->hsync_len + var->left_margin;
  2926. temp_p.htotal = xres + temp_p.hbend;
  2928. temp_p.vsstart = var->lower_margin;
  2929. temp_p.vsend = var->lower_margin + var->vsync_len;
  2930. temp_p.vbend =
  2931.     var->lower_margin + var->vsync_len + var->upper_margin;
  2932. temp_p.vtotal = var->yres + temp_p.vbend;
  2934. temp_p.stride = temp_p.width;
  2936. DPRINTK(2, "Using %d * %d, %d Khz, stride is %08xn",
  2937. temp_p.width, temp_p.height, temp_p.pixclock,
  2938. temp_p.stride);
  2940. temp_p.base =
  2941.     pm3fb_Shiftbpp(l_fb_info, temp_p.depth,
  2942.    (var->yoffset * xres) + var->xoffset);
  2944. temp_p.video = 0;
  2946. if (var->sync & FB_SYNC_HOR_HIGH_ACT)
  2947. temp_p.video |= PM3VideoControl_HSYNC_ACTIVE_HIGH;
  2948. else
  2949. temp_p.video |= PM3VideoControl_HSYNC_ACTIVE_LOW;
  2951. if (var->sync & FB_SYNC_VERT_HIGH_ACT)
  2952. temp_p.video |= PM3VideoControl_VSYNC_ACTIVE_HIGH;
  2953. else
  2954. temp_p.video |= PM3VideoControl_VSYNC_ACTIVE_LOW;
  2956. if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
  2957. DPRINTK(1, "Interlaced mode not supportednn");
  2958. return (-EINVAL);
  2959. }
  2961. if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE)
  2962. temp_p.video |= PM3VideoControl_LINE_DOUBLE_ON;
  2963. else
  2964. temp_p.video |= PM3VideoControl_LINE_DOUBLE_OFF;
  2966. if (var->activate == FB_ACTIVATE_NOW)
  2967. temp_p.video |= PM3VideoControl_ENABLE;
  2968. else {
  2969. temp_p.video |= PM3VideoControl_DISABLE;
  2970. DPRINTK(2, "PM3Video disabledn");
  2971. }
  2973. switch (temp_p.depth) {
  2974. case 8:
  2975. temp_p.video |= PM3VideoControl_PIXELSIZE_8BIT;
  2976. break;
  2977. case 12:
  2978. case 15:
  2979. case 16:
  2980. temp_p.video |= PM3VideoControl_PIXELSIZE_16BIT;
  2981. break;
  2982. case 32:
  2983. temp_p.video |= PM3VideoControl_PIXELSIZE_32BIT;
  2984. break;
  2985. default:
  2986. DPRINTK(1, "Unsupported depthn");
  2987. break;
  2988. }
  2989. }
  2990. (*p) = temp_p;
  2992. #ifdef PM3FB_USE_ACCEL
  2993. if (var->accel_flags & FB_ACCELF_TEXT)
  2994. noaccel[l_fb_info->board_num] = 0;
  2995. else
  2996. noaccel[l_fb_info->board_num] = 1;
  2997. #endif /* PM3FB_USE_ACCEL */
  2999. return (0);
  3000. }
  3002. static void pm3fb_encode_depth(struct fb_var_screeninfo *var, long d)
  3003. {
  3004. switch (d) {
  3005. case 8:
  3006. var->red.length = var->green.length = var->blue.length = 8;
  3007. var->red.offset = var->green.offset = var->blue.offset = 0;
  3008. var->transp.offset = var->transp.length = 0;
  3009. break;
  3011. case 12:
  3012. var->red.offset = 8;
  3013. var->red.length = 4;
  3014. var->green.offset = 4;
  3015. var->green.length = 4;
  3016. var->blue.offset = 0;
  3017. var->blue.length = 4;
  3018. var->transp.offset = 12;
  3019. var->transp.length = 4;
  3020. break;
  3022. case 15:
  3023. var->red.offset = 10;
  3024. var->red.length = 5;
  3025. var->green.offset = 5;
  3026. var->green.length = 5;
  3027. var->blue.offset = 0;
  3028. var->blue.length = 5;
  3029. var->transp.offset = 15;
  3030. var->transp.length = 1;
  3031. break;
  3033. case 16:
  3034. var->red.offset = 11;
  3035. var->red.length = 5;
  3036. var->green.offset = 5;
  3037. var->green.length = 6;
  3038. var->blue.offset = 0;
  3039. var->blue.length = 5;
  3040. var->transp.offset = var->transp.length = 0;
  3041. break;
  3043. case 32:
  3044. var->transp.offset = 24;
  3045. var->red.offset = 16;
  3046. var->green.offset = 8;
  3047. var->blue.offset = 0;
  3048. var->red.length = var->green.length =
  3049. var->blue.length = var->transp.length = 8;
  3050. break;
  3052. default:
  3053. DPRINTK(1, "Unsupported depth %ldn", d);
  3054. break;
  3055. }
  3056. }
  3058. static int pm3fb_encode_var(struct fb_var_screeninfo *var,
  3059.     const void *par, struct fb_info_gen *info)
  3060. {
  3061. struct pm3fb_par *p = (struct pm3fb_par *) par;
  3062. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3064. u32 base;
  3066. DTRACE;
  3068. DASSERT((var != NULL), "fb_var_screeninfo* not NULL");
  3069. DASSERT((p != NULL), "pm3fb_par* not NULL");
  3070. DASSERT((info != NULL), "fb_info_gen* not NULL");
  3072. memset(var, 0, sizeof(struct fb_var_screeninfo));
  3074. #ifdef PM3FB_USE_ACCEL
  3075. if (!(noaccel[l_fb_info->board_num]))
  3076. var->accel_flags |= FB_ACCELF_TEXT;
  3077. #endif /* PM3FB_USE_ACCEL */
  3079. var->xres_virtual = p->width;
  3080. var->yres_virtual = p->height;
  3081. var->xres = p->htotal - p->hbend;
  3082. var->yres = p->vtotal - p->vbend;
  3084. DPRINTK(2, "xres = %d, yres : %dn", var->xres, var->yres);
  3086. var->right_margin = p->hsstart;
  3087. var->hsync_len = p->hsend - p->hsstart;
  3088. var->left_margin = p->hbend - p->hsend;
  3089. var->lower_margin = p->vsstart;
  3090. var->vsync_len = p->vsend - p->vsstart;
  3091. var->upper_margin = p->vbend - p->vsend;
  3092. var->bits_per_pixel = depth2bpp(p->depth);
  3094. pm3fb_encode_depth(var, p->depth);
  3096. base = pm3fb_Unshiftbpp(l_fb_info, p->depth, p->base);
  3098. var->xoffset = base % var->xres;
  3099. var->yoffset = base / var->xres;
  3101. var->height = var->width = -1;
  3103. var->pixclock = KHZ2PICOS(p->pixclock);
  3105. if ((p->video & PM3VideoControl_HSYNC_MASK) ==
  3106.     PM3VideoControl_HSYNC_ACTIVE_HIGH)
  3107. var->sync |= FB_SYNC_HOR_HIGH_ACT;
  3108. if ((p->video & PM3VideoControl_VSYNC_MASK) ==
  3109.     PM3VideoControl_VSYNC_ACTIVE_HIGH)
  3110. var->sync |= FB_SYNC_VERT_HIGH_ACT;
  3111. if (p->video & PM3VideoControl_LINE_DOUBLE_ON)
  3112. var->vmode = FB_VMODE_DOUBLE;
  3114. return (0);
  3115. }
  3117. static void pm3fb_get_par(void *par, struct fb_info_gen *info)
  3118. {
  3119. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3121. DTRACE;
  3123. if (!current_par_valid[l_fb_info->board_num]) {
  3124. if (l_fb_info->use_current)
  3125. pm3fb_read_mode(l_fb_info, l_fb_info->current_par);
  3126. else
  3127. memcpy(l_fb_info->current_par,
  3128.        &(mode_base[0].user_mode),
  3129.        sizeof(struct pm3fb_par));
  3130. current_par_valid[l_fb_info->board_num] = 1;
  3131. }
  3132. *((struct pm3fb_par *) par) = *(l_fb_info->current_par);
  3133. }
  3135. static void pm3fb_set_par(const void *par, struct fb_info_gen *info)
  3136. {
  3137. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3139. DTRACE;
  3141. *(l_fb_info->current_par) = *((struct pm3fb_par *) par);
  3142. current_par_valid[l_fb_info->board_num] = 1;
  3144. pm3fb_write_mode(l_fb_info);
  3146. #ifdef PM3FB_USE_ACCEL
  3147. pm3fb_init_engine(l_fb_info);
  3148. #endif /* PM3FB_USE_ACCEL */
  3149. }
  3151. static void pm3fb_set_color(struct pm3fb_info *l_fb_info,
  3152.     unsigned char regno, unsigned char r,
  3153.     unsigned char g, unsigned char b)
  3154. {
  3155. DTRACE;
  3157. PM3_SLOW_WRITE_REG(PM3RD_PaletteWriteAddress, regno);
  3158. PM3_SLOW_WRITE_REG(PM3RD_PaletteData, r);
  3159. PM3_SLOW_WRITE_REG(PM3RD_PaletteData, g);
  3160. PM3_SLOW_WRITE_REG(PM3RD_PaletteData, b);
  3161. }
  3163. static int pm3fb_getcolreg(unsigned regno, unsigned *red, unsigned *green,
  3164.    unsigned *blue, unsigned *transp,
  3165.    struct fb_info *info)
  3166. {
  3167. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3169. DTRACE;
  3171. if (regno < 256) {
  3172. *red =
  3173.     l_fb_info->palette[regno].red << 8 | l_fb_info->
  3174.     palette[regno].red;
  3175. *green =
  3176.     l_fb_info->palette[regno].green << 8 | l_fb_info->
  3177.     palette[regno].green;
  3178. *blue =
  3179.     l_fb_info->palette[regno].blue << 8 | l_fb_info->
  3180.     palette[regno].blue;
  3181. *transp =
  3182.     l_fb_info->palette[regno].transp << 8 | l_fb_info->
  3183.     palette[regno].transp;
  3184. }
  3185. return (regno > 255);
  3186. }
  3188. static int pm3fb_setcolreg(unsigned regno, unsigned red, unsigned green,
  3189.    unsigned blue, unsigned transp,
  3190.    struct fb_info *info)
  3191. {
  3192. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3194. DTRACE;
  3196. if (regno < 16) {
  3197. switch (l_fb_info->current_par->depth) {
  3198. #ifdef FBCON_HAS_CFB8
  3199. case 8:
  3200. break;
  3201. #endif
  3202. #ifdef FBCON_HAS_CFB16
  3203. case 12:
  3204. l_fb_info->cmap.cmap12[regno] =
  3205. (((u32) red & 0xf000) >> 4) |
  3206. (((u32) green & 0xf000) >> 8) |
  3207. (((u32) blue & 0xf000) >> 12);
  3208. break;
  3210. case 15:
  3211. l_fb_info->cmap.cmap15[regno] =
  3212. (((u32) red & 0xf800) >> 1) |
  3213. (((u32) green & 0xf800) >> 6) |
  3214. (((u32) blue & 0xf800) >> 11);
  3215. break;
  3217. case 16:
  3218. l_fb_info->cmap.cmap16[regno] =
  3219.     ((u32) red & 0xf800) |
  3220.     (((u32) green & 0xfc00) >> 5) |
  3221.     (((u32) blue & 0xf800) >> 11);
  3222. break;
  3223. #endif
  3224. #ifdef FBCON_HAS_CFB32
  3225. case 32:
  3226. l_fb_info->cmap.cmap32[regno] =
  3227.     (((u32) transp & 0xff00) << 16) |
  3228.     (((u32) red & 0xff00) << 8) |
  3229.     (((u32) green & 0xff00)) |
  3230.     (((u32) blue & 0xff00) >> 8);
  3231. break;
  3232. #endif
  3233. default:
  3234. DPRINTK(1, "bad depth %un",
  3235. l_fb_info->current_par->depth);
  3236. break;
  3237. }
  3238. }
  3239. if (regno < 256) {
  3240. l_fb_info->palette[regno].red = red >> 8;
  3241. l_fb_info->palette[regno].green = green >> 8;
  3242. l_fb_info->palette[regno].blue = blue >> 8;
  3243. l_fb_info->palette[regno].transp = transp >> 8;
  3244. if (l_fb_info->current_par->depth == 8)
  3245. pm3fb_set_color(l_fb_info, regno, red >> 8,
  3246. green >> 8, blue >> 8);
  3247. }
  3248. return (regno > 255);
  3249. }
  3251. static int pm3fb_blank(int blank_mode, struct fb_info_gen *info)
  3252. {
  3253. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3254. u32 video;
  3256. DTRACE;
  3258. if (!current_par_valid[l_fb_info->board_num])
  3259. return (1);
  3261. video = l_fb_info->current_par->video;
  3263. /*
  3264.  * Oxygen VX1 - it appears that setting PM3VideoControl and
  3265.  * then PM3RD_SyncControl to the same SYNC settings undoes
  3266.  * any net change - they seem to xor together.  Only set the
  3267.  * sync options in PM3RD_SyncControl.  --rmk
  3268.  */
  3269. video &= ~(PM3VideoControl_HSYNC_MASK |
  3270.    PM3VideoControl_VSYNC_MASK);
  3271. video |= PM3VideoControl_HSYNC_ACTIVE_HIGH |
  3272.  PM3VideoControl_VSYNC_ACTIVE_HIGH;
  3274. if (blank_mode > 0) {
  3275. switch (blank_mode - 1) {
  3277. case VESA_NO_BLANKING: /* FIXME */
  3278. video = video & ~(PM3VideoControl_ENABLE);
  3279. break;
  3281. case VESA_HSYNC_SUSPEND:
  3282. video = video & ~(PM3VideoControl_HSYNC_MASK |
  3283.   PM3VideoControl_BLANK_ACTIVE_LOW);
  3284. break;
  3285. case VESA_VSYNC_SUSPEND:
  3286. video = video & ~(PM3VideoControl_VSYNC_MASK |
  3287.   PM3VideoControl_BLANK_ACTIVE_LOW);
  3288. break;
  3289. case VESA_POWERDOWN:
  3290. video = video & ~(PM3VideoControl_HSYNC_MASK |
  3291.   PM3VideoControl_VSYNC_MASK |
  3292.   PM3VideoControl_BLANK_ACTIVE_LOW);
  3293. break;
  3294. default:
  3295. DPRINTK(1, "Unsupported blanking %dn",
  3296. blank_mode);
  3297. return (1);
  3298. break;
  3299. }
  3300. }
  3302. PM3_SLOW_WRITE_REG(PM3VideoControl, video);
  3304. return (0);
  3305. }
  3307. static void pm3fb_set_disp(const void *par, struct display *disp,
  3308.    struct fb_info_gen *info)
  3309. {
  3310. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3311. struct pm3fb_par *p = (struct pm3fb_par *) par;
  3312. u32 flags;
  3314. DTRACE;
  3316. save_flags(flags);
  3317. cli();
  3318. disp->screen_base = l_fb_info->v_fb;
  3319. switch (p->depth) {
  3320. #ifdef FBCON_HAS_CFB8
  3321. case 8:
  3322. #ifdef PM3FB_USE_ACCEL
  3323. if (!(noaccel[l_fb_info->board_num]))
  3324. disp->dispsw = &pm3fb_cfb8;
  3325. else
  3326. #endif /* PM3FB_USE_ACCEL */
  3327. disp->dispsw = &fbcon_cfb8;
  3328. break;
  3329. #endif
  3330. #ifdef FBCON_HAS_CFB16
  3331. case 12:
  3332. #ifdef PM3FB_USE_ACCEL
  3333. if (!(noaccel[l_fb_info->board_num]))
  3334. disp->dispsw = &pm3fb_cfb16;
  3335. else
  3336. #endif /* PM3FB_USE_ACCEL */
  3337. disp->dispsw = &fbcon_cfb16;
  3338. disp->dispsw_data = l_fb_info->cmap.cmap12;
  3339. break;
  3340. case 15:
  3341. #ifdef PM3FB_USE_ACCEL
  3342. if (!(noaccel[l_fb_info->board_num]))
  3343. disp->dispsw = &pm3fb_cfb16;
  3344. else
  3345. #endif /* PM3FB_USE_ACCEL */
  3346. disp->dispsw = &fbcon_cfb16;
  3347. disp->dispsw_data = l_fb_info->cmap.cmap15;
  3348. break;
  3349. case 16:
  3350. #ifdef PM3FB_USE_ACCEL
  3351. if (!(noaccel[l_fb_info->board_num]))
  3352. disp->dispsw = &pm3fb_cfb16;
  3353. else
  3354. #endif /* PM3FB_USE_ACCEL */
  3355. disp->dispsw = &fbcon_cfb16;
  3356. disp->dispsw_data = l_fb_info->cmap.cmap16;
  3357. break;
  3358. #endif
  3359. #ifdef FBCON_HAS_CFB32
  3360. case 32:
  3361. #ifdef PM3FB_USE_ACCEL
  3362. if (!(noaccel[l_fb_info->board_num]))
  3363. disp->dispsw = &pm3fb_cfb32;
  3364. else
  3365. #endif /* PM3FB_USE_ACCEL */
  3366. disp->dispsw = &fbcon_cfb32;
  3367. disp->dispsw_data = l_fb_info->cmap.cmap32;
  3368. break;
  3369. #endif /* FBCON_HAS_CFB32 */
  3370. default:
  3371. disp->dispsw = &fbcon_dummy;
  3372. DPRINTK(1, "Invalid depth, using fbcon_dummyn");
  3373. break;
  3374. }
  3375. restore_flags(flags);
  3376. }
  3378. /* */
  3379. static void pm3fb_detect(void)
  3380. {
  3381. struct pci_dev *dev_array[PM3_MAX_BOARD];
  3382. struct pci_dev *dev = NULL;
  3383. struct pm3fb_info *l_fb_info = &(fb_info[0]);
  3384. unsigned long i, j, done;
  3386. DTRACE;
  3388. for (i = 0; i < PM3_MAX_BOARD; i++) {
  3389. dev_array[i] = NULL;
  3390. fb_info[i].dev = NULL;
  3391. }
  3393. dev =
  3394.     pci_find_device(PCI_VENDOR_ID_3DLABS,
  3395.     PCI_DEVICE_ID_3DLABS_PERMEDIA3, dev);
  3397. for (i = 0; ((i < PM3_MAX_BOARD) && dev); i++) {
  3398. dev_array[i] = dev;
  3399. dev =
  3400.     pci_find_device(PCI_VENDOR_ID_3DLABS,
  3401.     PCI_DEVICE_ID_3DLABS_PERMEDIA3, dev);
  3402. }
  3404. if (dev) { /* more than PM3_MAX_BOARD */
  3405. printk(KERN_WARNING "pm3fb: Warning: more than %d boards foundn",
  3406.        PM3_MAX_BOARD);
  3407. }
  3409. if (!dev_array[0]) { /* not a single board, abort */
  3410. return;
  3411. }
  3413. /* allocate user-defined boards */
  3414. for (i = 0; i < PM3_MAX_BOARD; i++) {
  3415. if ((bus[i] >= 0) && (slot[i] >= 0) && (func[i] >= 0)) {
  3416. for (j = 0; j < PM3_MAX_BOARD; j++) {
  3417. if ((dev_array[j] != NULL) &&
  3418.     (dev_array[j]->bus->number == bus[i])
  3419.     && (PCI_SLOT(dev_array[j]->devfn) ==
  3420. slot[i])
  3421.     && (PCI_FUNC(dev_array[j]->devfn) ==
  3422. func[i])) {
  3423. fb_info[i].dev = dev_array[j];
  3424. dev_array[j] = NULL;
  3425. }
  3426. }
  3427. }
  3428. }
  3429. /* allocate remaining boards */
  3430. for (i = 0; i < PM3_MAX_BOARD; i++) {
  3431. if (fb_info[i].dev == NULL) {
  3432. done = 0;
  3433. for (j = 0; ((j < PM3_MAX_BOARD) && (!done)); j++) {
  3434. if (dev_array[j] != NULL) {
  3435. fb_info[i].dev = dev_array[j];
  3436. dev_array[j] = NULL;
  3437. done = 1;
  3438. }
  3439. }
  3440. }
  3441. }
  3443. /* at that point, all PCI Permedia3 are detected and allocated */
  3444. /* now, initialize... or not */
  3445. for (i = 0; i < PM3_MAX_BOARD; i++) {
  3446. l_fb_info = &(fb_info[i]);
  3447. if ((l_fb_info->dev) && (!disable[i])) { /* PCI device was found and not disabled by user */
  3448. #ifdef SUPPORT_FB_OF
  3449. struct device_node *dp =
  3450.     find_pci_device_OFnode(l_fb_info->dev->bus->
  3451.    number,
  3452.    l_fb_info->dev->devfn);
  3454. if ((dp) && (!strncmp(dp->name, "formacGA12", 10))) {
  3455. /* do nothing, init of board is done in pm3fb_of_init */
  3456. } else {
  3457. #endif
  3458. DPRINTK(2,
  3459. "found @%lx Vendor %lx Device %lx ; base @ : %lx - %lx - %lx - %lx - %lx - %lx, irq %ldn",
  3460. (unsigned long) l_fb_info->dev,
  3461. (unsigned long) l_fb_info->dev->
  3462. vendor,
  3463. (unsigned long) l_fb_info->dev->
  3464. device,
  3465. (unsigned long)
  3466. pci_resource_start(l_fb_info->dev,
  3467.    0),
  3468. (unsigned long)
  3469. pci_resource_start(l_fb_info->dev,
  3470.    1),
  3471. (unsigned long)
  3472. pci_resource_start(l_fb_info->dev,
  3473.    2),
  3474. (unsigned long)
  3475. pci_resource_start(l_fb_info->dev,
  3476.    3),
  3477. (unsigned long)
  3478. pci_resource_start(l_fb_info->dev,
  3479.    4),
  3480. (unsigned long)
  3481. pci_resource_start(l_fb_info->dev,
  3482.    5),
  3483. (unsigned long) l_fb_info->dev->
  3484. irq);
  3486. l_fb_info->pIOBase =
  3487.     (unsigned char *)
  3488.     pci_resource_start(l_fb_info->dev, 0);
  3489. #ifdef __BIG_ENDIAN
  3490. l_fb_info->pIOBase += PM3_REGS_SIZE;
  3491. #endif
  3492. l_fb_info->vIOBase = (unsigned char *) -1;
  3493. l_fb_info->p_fb =
  3494.     (unsigned char *)
  3495.     pci_resource_start(l_fb_info->dev, 1);
  3496. l_fb_info->v_fb = (unsigned char *) -1;
  3498. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)  /* full resource management, new in linux-2.4.x */
  3499. if (!request_mem_region
  3500.     ((unsigned long)l_fb_info->p_fb, 64 * 1024 * 1024, /* request full aperture size */
  3501.      "pm3fb")) {
  3502. printk
  3503.     (KERN_ERR "pm3fb: Error: couldn't request framebuffer memory, board #%ldn",
  3504.      l_fb_info->board_num);
  3505. continue;
  3506. }
  3507. if (!request_mem_region
  3508.     ((unsigned long)l_fb_info->pIOBase, PM3_REGS_SIZE,
  3509.      "pm3fb I/O regs")) {
  3510. printk
  3511.     (KERN_ERR "pm3fb: Error: couldn't request IObase memory, board #%ldn",
  3512.      l_fb_info->board_num);
  3513. continue;
  3514. }
  3515. #endif /* KERNEL_2_4 or KERNEL_2_5 */
  3516. if (forcesize[l_fb_info->board_num])
  3517. l_fb_info->fb_size = forcesize[l_fb_info->board_num];
  3519. l_fb_info->fb_size =
  3520.     pm3fb_size_memory(l_fb_info);
  3522. if (l_fb_info->fb_size) {
  3523. (void) pci_enable_device(l_fb_info->dev);
  3524. pm3fb_common_init(l_fb_info);
  3525. } else
  3526. printk(KERN_ERR "pm3fb: memory problem, not enabling board #%ldn", l_fb_info->board_num);
  3528. #ifdef SUPPORT_FB_OF
  3529. }
  3530. #endif /* SUPPORT_FB_OF */
  3531. }
  3532. }
  3533. }
  3535. static int pm3fb_pan_display(const struct fb_var_screeninfo *var,
  3536.      struct fb_info_gen *info)
  3537. {
  3538. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3540. DTRACE;
  3542. if (!current_par_valid[l_fb_info->board_num])
  3543. return -EINVAL;
  3545. l_fb_info->current_par->base = /* in 128 bits chunk - i.e. AFTER Shiftbpp */
  3546.     pm3fb_Shiftbpp(l_fb_info,
  3547.    l_fb_info->current_par->depth,
  3548.    (var->yoffset * l_fb_info->current_par->width) +
  3549.    var->xoffset);
  3550. PM3_SLOW_WRITE_REG(PM3ScreenBase, l_fb_info->current_par->base);
  3551. return 0;
  3552. }
  3554. static int pm3fb_ioctl(struct inode *inode, struct file *file,
  3555.                        u_int cmd, u_long arg, int con,
  3556.        struct fb_info *info)
  3557. {
  3558. struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
  3559. u32 cm, i;
  3560. #ifdef PM3FB_MASTER_DEBUG
  3561. char cc[3];
  3562. #endif /* PM3FB_MASTER_DEBUG */
  3564. switch(cmd)
  3565. {
  3566. #ifdef PM3FB_MASTER_DEBUG
  3567. case PM3FBIO_CLEARMEMORY:
  3568. if (copy_from_user(&cm, (void *)arg, sizeof(u32)))
  3569. return(-EFAULT);
  3570. pm3fb_clear_memory(l_fb_info, cm);
  3571. return(0);
  3572. break;
  3574. case PM3FBIO_CLEARCMAP:
  3575. if (copy_from_user(cc, (void*)arg, 3 * sizeof(char)))
  3576. return(-EFAULT);
  3577. pm3fb_clear_colormap(l_fb_info, cc[0], cc[1], cc[2]);
  3578. return(0);
  3579. break;
  3580. #endif /* PM3FB_MASTER_DEBUG */
  3582. case PM3FBIO_RESETCHIP:
  3583. cm = 1;
  3584. PM3_SLOW_WRITE_REG(PM3ResetStatus, 1);
  3585. for (i = 0 ; (i < 10000) && cm ; i++)
  3586. {
  3587. PM3_DELAY(10);
  3588. cm = PM3_READ_REG(PM3ResetStatus);
  3589. }
  3590. if (cm)
  3591. {
  3592. printk(KERN_ERR "pm3fb: chip reset failed with status 0x%xn", cm);
  3593. return(-EIO);
  3594. }
  3595. /* first thing first, reload memory timings */
  3596. pm3fb_write_memory_timings(l_fb_info);
  3597. #ifdef PM3FB_USE_ACCEL
  3598. pm3fb_init_engine(l_fb_info);
  3599. #endif /* PM3FB_USE_ACCEL */
  3600. pm3fb_write_mode(l_fb_info);
  3601. return(0);
  3602. break;
  3604. default:
  3605. DPRINTK(2, "unknown ioctl: %d (%x)n", cmd, cmd);
  3606. return(-EINVAL);
  3607. }
  3608. }
  3610. /* ****************************************** */
  3611. /* ***** standard FB API init functions ***** */
  3612. /* ****************************************** */
  3614. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  3615. int __init pm3fb_setup(char *options)
  3616. #endif
  3617. #ifdef KERNEL_2_2
  3618. __initfunc(void pm3fb_setup(char *options, int *ints))
  3619. #endif
  3620. {
  3621. long opsi = strlen(options);
  3623. DTRACE;
  3625. memcpy(g_options, options,
  3626.        ((opsi + 1) >
  3627. PM3_OPTIONS_SIZE) ? PM3_OPTIONS_SIZE : (opsi + 1));
  3628. g_options[PM3_OPTIONS_SIZE - 1] = 0;
  3630. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  3631. return (0);
  3632. #endif
  3633. }
  3635. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  3636. int __init pm3fb_init(void)
  3637. #endif
  3638. #ifdef KERNEL_2_2
  3639. __initfunc(void pm3fb_init(void))
  3640. #endif
  3641. {
  3642. DTRACE;
  3644. DPRINTK(2, "This is pm3fb.c, CVS version: $Header: /cvsroot/linux/drivers/video/pm3fb.c,v 1.1 2002/02/25 19:11:06 marcelo Exp $");
  3646. pm3fb_real_setup(g_options);
  3648. pm3fb_detect();
  3650. if (!fb_info[0].dev) { /* not even one board ??? */
  3651. DPRINTK(1, "No PCI Permedia3 board detectedn");
  3652. }
  3653. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  3654. return (0);
  3655. #endif
  3656. }
  3658. #ifdef SUPPORT_FB_OF /* linux-2.2.x only */
  3659. __initfunc(void pm3fb_of_init(struct device_node *dp))
  3660. {
  3661. struct pm3fb_info *l_fb_info = NULL;
  3662. unsigned long i;
  3663. long bn = -1;
  3664. struct device_node *dn;
  3666. DTRACE;
  3668. DPRINTK(2, "OpenFirmware board : %sn", dp->full_name);
  3670. for (i = 0; i < dp->n_addrs; i++) {
  3671. DPRINTK(2, "MemRange : 0x%08x - 0x%xn",
  3672. dp->addrs[i].address, dp->addrs[i].size);
  3673. }
  3675. for (i = 0; i < PM3_MAX_BOARD; i++) { /* find which PCI board is the OF device */
  3676. if (fb_info[i].dev) {
  3677. dn = find_pci_device_OFnode(fb_info[i].dev->bus->
  3678.     number,
  3679.     fb_info[i].dev->devfn);
  3680. if (dn == dp) {
  3681. if (bn == -1)
  3682. bn = i;
  3683. else {
  3684. DPRINTK(1,
  3685. "Error: Multiple PCI device for a single OpenFirmware noden");
  3686. }
  3687. }
  3688. }
  3689. }
  3691. if (bn == -1) {
  3692. DPRINTK(1, "Warning: non-PCI Permedia3 foundn");
  3693. i = 0;
  3694. while (fb_info[i].dev && (i < PM3_MAX_BOARD))
  3695. i++;
  3696. if (i < PM3_MAX_BOARD)
  3697. bn = i;
  3698. else {
  3699. printk
  3700.     (KERN_ERR "pm3fb: Error: Couldn't find room for OpenFirmware device");
  3701. return;
  3702. }
  3703. }
  3705. l_fb_info = &(fb_info[bn]);
  3707. l_fb_info->dn = dp;
  3709. l_fb_info->pIOBase = (unsigned char *) dp->addrs[3].address;
  3710. #ifdef __BIG_ENDIAN
  3711. l_fb_info->pIOBase += PM3_REGS_SIZE;
  3712. #endif
  3713. l_fb_info->vIOBase = (unsigned char *) -1;
  3714. l_fb_info->p_fb = (unsigned char *) dp->addrs[1].address;
  3715. l_fb_info->v_fb = (unsigned char *) -1;
  3717. l_fb_info->fb_size = pm3fb_size_memory(l_fb_info); /* (unsigned long)dp->addrs[1].size; *//* OF is a liar ! it claims 256 Mb */
  3719. DPRINTK(2,
  3720. "OpenFirmware board (#%ld) : IOBase 0x%08lx, p_fb 0x%08lx, fb_size %d KBn",
  3721. bn, (unsigned long) l_fb_info->pIOBase,
  3722. (unsigned long) l_fb_info->p_fb, l_fb_info->fb_size >> 10);
  3724. l_fb_info->use_current = 1; /* will use current mode by default */
  3726. pm3fb_common_init(l_fb_info);
  3727. }
  3728. #endif /* SUPPORT_FB_OF */
  3730. /* ************************* */
  3731. /* **** Module support ***** */
  3732. /* ************************* */
  3734. #ifdef MODULE
  3735. MODULE_AUTHOR("Romain Dolbeau");
  3736. MODULE_DESCRIPTION("Permedia3 framebuffer device driver");
  3737. static char *mode[PM3_MAX_BOARD];
  3738. MODULE_PARM(mode,PM3_MAX_BOARD_MODULE_ARRAY_STRING);
  3739. MODULE_PARM_DESC(mode,"video mode");
  3740. MODULE_PARM(disable,PM3_MAX_BOARD_MODULE_ARRAY_SHORT);
  3741. MODULE_PARM_DESC(disable,"disable board");
  3742. static short off[PM3_MAX_BOARD];
  3743. MODULE_PARM(off,PM3_MAX_BOARD_MODULE_ARRAY_SHORT);
  3744. MODULE_PARM_DESC(off,"disable board");
  3745. static char *pciid[PM3_MAX_BOARD];
  3746. MODULE_PARM(pciid,PM3_MAX_BOARD_MODULE_ARRAY_STRING);
  3747. MODULE_PARM_DESC(pciid,"board PCI Id");
  3748. MODULE_PARM(noaccel,PM3_MAX_BOARD_MODULE_ARRAY_SHORT);
  3749. MODULE_PARM_DESC(noaccel,"disable accel");
  3750. static char *font[PM3_MAX_BOARD];
  3751. MODULE_PARM(font,PM3_MAX_BOARD_MODULE_ARRAY_STRING);
  3752. MODULE_PARM_DESC(font,"choose font");
  3753. MODULE_PARM(depth,PM3_MAX_BOARD_MODULE_ARRAY_SHORT);
  3754. MODULE_PARM_DESC(depth,"boot-time depth");
  3755. MODULE_PARM(printtimings, "h");
  3756. MODULE_PARM_DESC(printtimings, "print the memory timings of the card(s)");
  3757. MODULE_PARM(forcesize, PM3_MAX_BOARD_MODULE_ARRAY_SHORT);
  3758. MODULE_PARM_DESC(forcesize, "force specified memory size");
  3759. /*
  3760. MODULE_SUPPORTED_DEVICE("Permedia3 PCI boards")
  3761. MODULE_GENERIC_TABLE(gtype,name)
  3762. MODULE_DEVICE_TABLE(type,name)
  3763. */
  3765. void pm3fb_build_options(void)
  3766. {
  3767. int i;
  3768. char ts[128];
  3770. strcpy(g_options, "pm3fb");
  3771. for (i = 0; i < PM3_MAX_BOARD ; i++)
  3772. {
  3773. if (mode[i])
  3774. {
  3775. sprintf(ts, ",mode:%d:%s", i, mode[i]);
  3776. strncat(g_options, ts, PM3_OPTIONS_SIZE - strlen(g_options));
  3777. }
  3778. if (disable[i] || off[i])
  3779. {
  3780. sprintf(ts, ",disable:%d:", i);
  3781. strncat(g_options, ts, PM3_OPTIONS_SIZE - strlen(g_options));
  3782. }
  3783. if (pciid[i])
  3784. {
  3785. sprintf(ts, ",pciid:%d:%s", i, pciid[i]);
  3786. strncat(g_options, ts, PM3_OPTIONS_SIZE - strlen(g_options));
  3787. }
  3788. if (noaccel[i])
  3789. {
  3790. sprintf(ts, ",noaccel:%d:", i);
  3791. strncat(g_options, ts, PM3_OPTIONS_SIZE - strlen(g_options));
  3792. }
  3793. if (font[i])
  3794. {
  3795. sprintf(ts, ",font:%d:%s", i, font[i]);
  3796. strncat(g_options, ts, PM3_OPTIONS_SIZE - strlen(g_options));
  3797. }
  3798. if (depth[i])
  3799. {
  3800. sprintf(ts, ",depth:%d:%d", i, depth[i]);
  3801. strncat(g_options, ts, PM3_OPTIONS_SIZE - strlen(g_options));
  3802. }
  3803. }
  3804. g_options[PM3_OPTIONS_SIZE - 1] = '';
  3805. DPRINTK(1, "pm3fb use options: %sn", g_options);
  3806. }
  3808. int init_module(void)
  3809. {
  3810. DTRACE;
  3812. pm3fb_build_options();
  3814. pm3fb_init();
  3816. return (0);
  3817. }
  3819. void cleanup_module(void)
  3820. {
  3821. DTRACE;
  3822. {
  3823. unsigned long i;
  3824. struct pm3fb_info *l_fb_info;
  3825. for (i = 0; i < PM3_MAX_BOARD; i++) {
  3826. l_fb_info = &(fb_info[i]);
  3827. if ((l_fb_info->dev != NULL)
  3828.     && (!(disable[l_fb_info->board_num]))) {
  3829. if (l_fb_info->vIOBase !=
  3830.     (unsigned char *) -1) {
  3831. pm3fb_unmapIO(l_fb_info);
  3832. #if (defined KERNEL_2_4) || (defined KERNEL_2_5)
  3833. release_mem_region(l_fb_info->p_fb,
  3834.    l_fb_info->
  3835.    fb_size);
  3836. release_mem_region(l_fb_info->
  3837.    pIOBase,
  3838.    PM3_REGS_SIZE);
  3839. #endif /* KERNEL_2_4 or KERNEL_2_5 */
  3840. }
  3841. unregister_framebuffer(&l_fb_info->gen.
  3842.        info);
  3843. }
  3844. }
  3845. }
  3846. return;
  3847. }
  3848. #endif /* MODULE */