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

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

Linux/Unix编程

开发平台：

Unix_Linux

vreset.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.vreset.c 1.13 01/11/02 10:46:08 trini
  3.  */
  4. /*
  5.  * vreset.c
  6.  *
  7.  * Initialize the VGA control registers to 80x25 text mode.
  8.  *
  9.  * Adapted from a program by:
  10.  *                                      Steve Sellgren
  11.  *                                      San Francisco Indigo Company
  12.  *                                      sfindigo!sellgren@uunet.uu.net
  13.  *
  14.  * Original concept by:
  15.  *                                      Gary Thomas <gdt@linuxppc.org>
  16.  * Adapted for Moto boxes by:
  17.  *                                      Pat Kane & Mark Scott, 1996
  18.  * Adapted for IBM portables by:
  19.  *                                      Takeshi Ishimoto
  20.  * Multi-console support:
  21.  *                                      Terje Malmedal <terje.malmedal@usit.uio.no>
  22.  */
  24. #include "iso_font.h"
  25. #include "nonstdio.h"
  27. extern char *vidmem;
  28. extern int lines, cols;
  29. struct VaRegs;
  31. /*
  32.  * VGA Register
  33.  */
  34. struct VgaRegs
  35. {
  36. unsigned short io_port;
  37. unsigned char  io_index;
  38. unsigned char  io_value;
  39. };
  41. void unlockVideo(int slot);
  42. void setTextRegs(struct VgaRegs *svp);
  43. void setTextCLUT(int shift);
  44. void clearVideoMemory(void);
  45. void loadFont(unsigned char *ISA_mem);
  47. static void mdelay(int ms)
  48. {
  49. for (; ms > 0; --ms)
  50. udelay(1000);
  51. }
  53. /*
  54.  * Default console text mode registers  used to reset
  55.  * graphics adapter.
  56.  */
  57. #define NREGS 54
  58. #define ENDMK  0xFFFF  /* End marker */
  60. #define S3Vendor 0x5333
  61. #define CirrusVendor    0x1013
  62. #define DiamondVendor   0x100E
  63. #define MatroxVendor    0x102B
  64. #define ParadiseVendor  0x101C
  66. struct VgaRegs GenVgaTextRegs[NREGS+1] = {
  67. /* port index value  */
  68. /* SR Regs */
  69. { 0x3c4, 0x1, 0x0 },
  70. { 0x3c4, 0x2, 0x3 },
  71. { 0x3c4, 0x3, 0x0 },
  72. { 0x3c4, 0x4, 0x2 },
  73.  /* CR Regs */
  74. { 0x3d4, 0x0, 0x5f },
  75. { 0x3d4, 0x1, 0x4f },
  76. { 0x3d4, 0x2, 0x50 },
  77. { 0x3d4, 0x3, 0x82 },
  78. { 0x3d4, 0x4, 0x55 },
  79. { 0x3d4, 0x5, 0x81 },
  80. { 0x3d4, 0x6, 0xbf },
  81. { 0x3d4, 0x7, 0x1f },
  82. { 0x3d4, 0x8, 0x00 },
  83. { 0x3d4, 0x9, 0x4f },
  84. { 0x3d4, 0xa, 0x0d },
  85. { 0x3d4, 0xb, 0x0e },
  86. { 0x3d4, 0xc, 0x00 },
  87. { 0x3d4, 0xd, 0x00 },
  88. { 0x3d4, 0xe, 0x00 },
  89. { 0x3d4, 0xf, 0x00 },
  90. { 0x3d4, 0x10, 0x9c },
  91. { 0x3d4, 0x11, 0x8e },
  92. { 0x3d4, 0x12, 0x8f },
  93. { 0x3d4, 0x13, 0x28 },
  94. { 0x3d4, 0x14, 0x1f },
  95. { 0x3d4, 0x15, 0x96 },
  96. { 0x3d4, 0x16, 0xb9 },
  97. { 0x3d4, 0x17, 0xa3 },
  98.  /* GR Regs */
  99. { 0x3ce, 0x0, 0x0 },
  100. { 0x3ce, 0x1, 0x0 },
  101. { 0x3ce, 0x2, 0x0 },
  102. { 0x3ce, 0x3, 0x0 },
  103. { 0x3ce, 0x4, 0x0 },
  104. { 0x3ce, 0x5, 0x10 },
  105. { 0x3ce, 0x6, 0xe },
  106. { 0x3ce, 0x7, 0x0 },
  107. { 0x3ce, 0x8, 0xff },
  108. { ENDMK }
  109. };
  111. struct RGBColors
  112. {
  113.   unsigned char r, g, b;
  114. };
  116. /*
  117.  * Default console text mode color table.
  118.  * These values were obtained by booting Linux with
  119.  * text mode firmware & then dumping the registers.
  120.  */
  121. struct RGBColors TextCLUT[256] =
  122. {
  123. /* red green blue  */
  124. { 0x0, 0x0, 0x0 },
  125. { 0x0, 0x0, 0x2a },
  126. { 0x0, 0x2a, 0x0 },
  127. { 0x0, 0x2a, 0x2a },
  128. { 0x2a, 0x0, 0x0 },
  129. { 0x2a, 0x0, 0x2a },
  130. { 0x2a, 0x2a, 0x0 },
  131. { 0x2a, 0x2a, 0x2a },
  132. { 0x0, 0x0, 0x15 },
  133. { 0x0, 0x0, 0x3f },
  134. { 0x0, 0x2a, 0x15 },
  135. { 0x0, 0x2a, 0x3f },
  136. { 0x2a, 0x0, 0x15 },
  137. { 0x2a, 0x0, 0x3f },
  138. { 0x2a, 0x2a, 0x15 },
  139. { 0x2a, 0x2a, 0x3f },
  140. { 0x0, 0x15, 0x0 },
  141. { 0x0, 0x15, 0x2a },
  142. { 0x0, 0x3f, 0x0 },
  143. { 0x0, 0x3f, 0x2a },
  144. { 0x2a, 0x15, 0x0 },
  145. { 0x2a, 0x15, 0x2a },
  146. { 0x2a, 0x3f, 0x0 },
  147. { 0x2a, 0x3f, 0x2a },
  148. { 0x0, 0x15, 0x15 },
  149. { 0x0, 0x15, 0x3f },
  150. { 0x0, 0x3f, 0x15 },
  151. { 0x0, 0x3f, 0x3f },
  152. { 0x2a, 0x15, 0x15 },
  153. { 0x2a, 0x15, 0x3f },
  154. { 0x2a, 0x3f, 0x15 },
  155. { 0x2a, 0x3f, 0x3f },
  156. { 0x15, 0x0, 0x0 },
  157. { 0x15, 0x0, 0x2a },
  158. { 0x15, 0x2a, 0x0 },
  159. { 0x15, 0x2a, 0x2a },
  160. { 0x3f, 0x0, 0x0 },
  161. { 0x3f, 0x0, 0x2a },
  162. { 0x3f, 0x2a, 0x0 },
  163. { 0x3f, 0x2a, 0x2a },
  164. { 0x15, 0x0, 0x15 },
  165. { 0x15, 0x0, 0x3f },
  166. { 0x15, 0x2a, 0x15 },
  167. { 0x15, 0x2a, 0x3f },
  168. { 0x3f, 0x0, 0x15 },
  169. { 0x3f, 0x0, 0x3f },
  170. { 0x3f, 0x2a, 0x15 },
  171. { 0x3f, 0x2a, 0x3f },
  172. { 0x15, 0x15, 0x0 },
  173. { 0x15, 0x15, 0x2a },
  174. { 0x15, 0x3f, 0x0 },
  175. { 0x15, 0x3f, 0x2a },
  176. { 0x3f, 0x15, 0x0 },
  177. { 0x3f, 0x15, 0x2a },
  178. { 0x3f, 0x3f, 0x0 },
  179. { 0x3f, 0x3f, 0x2a },
  180. { 0x15, 0x15, 0x15 },
  181. { 0x15, 0x15, 0x3f },
  182. { 0x15, 0x3f, 0x15 },
  183. { 0x15, 0x3f, 0x3f },
  184. { 0x3f, 0x15, 0x15 },
  185. { 0x3f, 0x15, 0x3f },
  186. { 0x3f, 0x3f, 0x15 },
  187. { 0x3f, 0x3f, 0x3f },
  188. { 0x39, 0xc, 0x5 },
  189. { 0x15, 0x2c, 0xf },
  190. { 0x26, 0x10, 0x3d },
  191. { 0x29, 0x29, 0x38 },
  192. { 0x4, 0x1a, 0xe },
  193. { 0x2, 0x1e, 0x3a },
  194. { 0x3c, 0x25, 0x33 },
  195. { 0x3c, 0xc, 0x2c },
  196. { 0x3f, 0x3, 0x2b },
  197. { 0x1c, 0x9, 0x13 },
  198. { 0x25, 0x2a, 0x35 },
  199. { 0x1e, 0xa, 0x38 },
  200. { 0x24, 0x8, 0x3 },
  201. { 0x3, 0xe, 0x36 },
  202. { 0xc, 0x6, 0x2a },
  203. { 0x26, 0x3, 0x32 },
  204. { 0x5, 0x2f, 0x33 },
  205. { 0x3c, 0x35, 0x2f },
  206. { 0x2d, 0x26, 0x3e },
  207. { 0xd, 0xa, 0x10 },
  208. { 0x25, 0x3c, 0x11 },
  209. { 0xd, 0x4, 0x2e },
  210. { 0x5, 0x19, 0x3e },
  211. { 0xc, 0x13, 0x34 },
  212. { 0x2b, 0x6, 0x24 },
  213. { 0x4, 0x3, 0xd },
  214. { 0x2f, 0x3c, 0xc },
  215. { 0x2a, 0x37, 0x1f },
  216. { 0xf, 0x12, 0x38 },
  217. { 0x38, 0xe, 0x2a },
  218. { 0x12, 0x2f, 0x19 },
  219. { 0x29, 0x2e, 0x31 },
  220. { 0x25, 0x13, 0x3e },
  221. { 0x33, 0x3e, 0x33 },
  222. { 0x1d, 0x2c, 0x25 },
  223. { 0x15, 0x15, 0x5 },
  224. { 0x32, 0x25, 0x39 },
  225. { 0x1a, 0x7, 0x1f },
  226. { 0x13, 0xe, 0x1d },
  227. { 0x36, 0x17, 0x34 },
  228. { 0xf, 0x15, 0x23 },
  229. { 0x2, 0x35, 0xd },
  230. { 0x15, 0x3f, 0xc },
  231. { 0x14, 0x2f, 0xf },
  232. { 0x19, 0x21, 0x3e },
  233. { 0x27, 0x11, 0x2f },
  234. { 0x38, 0x3f, 0x3c },
  235. { 0x36, 0x2d, 0x15 },
  236. { 0x16, 0x17, 0x2 },
  237. { 0x1, 0xa, 0x3d },
  238. { 0x1b, 0x11, 0x3f },
  239. { 0x21, 0x3c, 0xd },
  240. { 0x1a, 0x39, 0x3d },
  241. { 0x8, 0xe, 0xe },
  242. { 0x22, 0x21, 0x23 },
  243. { 0x1e, 0x30, 0x5 },
  244. { 0x1f, 0x22, 0x3d },
  245. { 0x1e, 0x2f, 0xa },
  246. { 0x0, 0x1c, 0xe },
  247. { 0x0, 0x1c, 0x15 },
  248. { 0x0, 0x1c, 0x1c },
  249. { 0x0, 0x15, 0x1c },
  250. { 0x0, 0xe, 0x1c },
  251. { 0x0, 0x7, 0x1c },
  252. { 0xe, 0xe, 0x1c },
  253. { 0x11, 0xe, 0x1c },
  254. { 0x15, 0xe, 0x1c },
  255. { 0x18, 0xe, 0x1c },
  256. { 0x1c, 0xe, 0x1c },
  257. { 0x1c, 0xe, 0x18 },
  258. { 0x1c, 0xe, 0x15 },
  259. { 0x1c, 0xe, 0x11 },
  260. { 0x1c, 0xe, 0xe },
  261. { 0x1c, 0x11, 0xe },
  262. { 0x1c, 0x15, 0xe },
  263. { 0x1c, 0x18, 0xe },
  264. { 0x1c, 0x1c, 0xe },
  265. { 0x18, 0x1c, 0xe },
  266. { 0x15, 0x1c, 0xe },
  267. { 0x11, 0x1c, 0xe },
  268. { 0xe, 0x1c, 0xe },
  269. { 0xe, 0x1c, 0x11 },
  270. { 0xe, 0x1c, 0x15 },
  271. { 0xe, 0x1c, 0x18 },
  272. { 0xe, 0x1c, 0x1c },
  273. { 0xe, 0x18, 0x1c },
  274. { 0xe, 0x15, 0x1c },
  275. { 0xe, 0x11, 0x1c },
  276. { 0x14, 0x14, 0x1c },
  277. { 0x16, 0x14, 0x1c },
  278. { 0x18, 0x14, 0x1c },
  279. { 0x1a, 0x14, 0x1c },
  280. { 0x1c, 0x14, 0x1c },
  281. { 0x1c, 0x14, 0x1a },
  282. { 0x1c, 0x14, 0x18 },
  283. { 0x1c, 0x14, 0x16 },
  284. { 0x1c, 0x14, 0x14 },
  285. { 0x1c, 0x16, 0x14 },
  286. { 0x1c, 0x18, 0x14 },
  287. { 0x1c, 0x1a, 0x14 },
  288. { 0x1c, 0x1c, 0x14 },
  289. { 0x1a, 0x1c, 0x14 },
  290. { 0x18, 0x1c, 0x14 },
  291. { 0x16, 0x1c, 0x14 },
  292. { 0x14, 0x1c, 0x14 },
  293. { 0x14, 0x1c, 0x16 },
  294. { 0x14, 0x1c, 0x18 },
  295. { 0x14, 0x1c, 0x1a },
  296. { 0x14, 0x1c, 0x1c },
  297. { 0x14, 0x1a, 0x1c },
  298. { 0x14, 0x18, 0x1c },
  299. { 0x14, 0x16, 0x1c },
  300. { 0x0, 0x0, 0x10 },
  301. { 0x4, 0x0, 0x10 },
  302. { 0x8, 0x0, 0x10 },
  303. { 0xc, 0x0, 0x10 },
  304. { 0x10, 0x0, 0x10 },
  305. { 0x10, 0x0, 0xc },
  306. { 0x10, 0x0, 0x8 },
  307. { 0x10, 0x0, 0x4 },
  308. { 0x10, 0x0, 0x0 },
  309. { 0x10, 0x4, 0x0 },
  310. { 0x10, 0x8, 0x0 },
  311. { 0x10, 0xc, 0x0 },
  312. { 0x10, 0x10, 0x0 },
  313. { 0xc, 0x10, 0x0 },
  314. { 0x8, 0x10, 0x0 },
  315. { 0x4, 0x10, 0x0 },
  316. { 0x0, 0x10, 0x0 },
  317. { 0x0, 0x10, 0x4 },
  318. { 0x0, 0x10, 0x8 },
  319. { 0x0, 0x10, 0xc },
  320. { 0x0, 0x10, 0x10 },
  321. { 0x0, 0xc, 0x10 },
  322. { 0x0, 0x8, 0x10 },
  323. { 0x0, 0x4, 0x10 },
  324. { 0x8, 0x8, 0x10 },
  325. { 0xa, 0x8, 0x10 },
  326. { 0xc, 0x8, 0x10 },
  327. { 0xe, 0x8, 0x10 },
  328. { 0x10, 0x8, 0x10 },
  329. { 0x10, 0x8, 0xe },
  330. { 0x10, 0x8, 0xc },
  331. { 0x10, 0x8, 0xa },
  332. { 0x10, 0x8, 0x8 },
  333. { 0x10, 0xa, 0x8 },
  334. { 0x10, 0xc, 0x8 },
  335. { 0x10, 0xe, 0x8 },
  336. { 0x10, 0x10, 0x8 },
  337. { 0xe, 0x10, 0x8 },
  338. { 0xc, 0x10, 0x8 },
  339. { 0xa, 0x10, 0x8 },
  340. { 0x8, 0x10, 0x8 },
  341. { 0x8, 0x10, 0xa },
  342. { 0x8, 0x10, 0xc },
  343. { 0x8, 0x10, 0xe },
  344. { 0x8, 0x10, 0x10 },
  345. { 0x8, 0xe, 0x10 },
  346. { 0x8, 0xc, 0x10 },
  347. { 0x8, 0xa, 0x10 },
  348. { 0xb, 0xb, 0x10 },
  349. { 0xc, 0xb, 0x10 },
  350. { 0xd, 0xb, 0x10 },
  351. { 0xf, 0xb, 0x10 },
  352. { 0x10, 0xb, 0x10 },
  353. { 0x10, 0xb, 0xf },
  354. { 0x10, 0xb, 0xd },
  355. { 0x10, 0xb, 0xc },
  356. { 0x10, 0xb, 0xb },
  357. { 0x10, 0xc, 0xb },
  358. { 0x10, 0xd, 0xb },
  359. { 0x10, 0xf, 0xb },
  360. { 0x10, 0x10, 0xb },
  361. { 0xf, 0x10, 0xb },
  362. { 0xd, 0x10, 0xb },
  363. { 0xc, 0x10, 0xb },
  364. { 0xb, 0x10, 0xb },
  365. { 0xb, 0x10, 0xc },
  366. { 0xb, 0x10, 0xd },
  367. { 0xb, 0x10, 0xf },
  368. { 0xb, 0x10, 0x10 },
  369. { 0xb, 0xf, 0x10 },
  370. { 0xb, 0xd, 0x10 },
  371. { 0xb, 0xc, 0x10 },
  372. { 0x0, 0x0, 0x0 },
  373. { 0x0, 0x0, 0x0 },
  374. { 0x0, 0x0, 0x0 },
  375. { 0x0, 0x0, 0x0 },
  376. { 0x0, 0x0, 0x0 },
  377. { 0x0, 0x0, 0x0 },
  378. { 0x0, 0x0, 0x0 }
  379. };
  381. unsigned char AC[21] = {
  382.     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
  383.     0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
  384.     0x0C, 0x00, 0x0F, 0x08, 0x00};
  386. static int scanPCI(int start_slt);
  387. static int PCIVendor(int);
  388. #ifdef DEBUG
  389. static void printslots(void);
  390. #endif
  391. extern void puthex(unsigned long);
  392. extern void puts(const char *);
  393. static void unlockS3(void);
  395. static void inline
  396. outw(int port, unsigned short val)
  397. {
  398. outb(port, val >> 8);
  399. outb(port+1, val);
  400. }
  402. int
  403. vga_init(unsigned char *ISA_mem)
  404. {
  405. int slot;
  406. struct VgaRegs *VgaTextRegs;
  408. /* See if VGA already in TEXT mode - exit if so! */
  409. outb(0x3CE, 0x06);
  410. if ((inb(0x3CF) & 0x01) == 0){
  411. puts("VGA already in text moden");
  412. return 0;
  413. }
  415. /* If no VGA responding in text mode, then we have some work to do...
  416.  */
  417. slot = -1;
  418. while((slot = scanPCI(slot)) > -1) { /* find video card in use  */
  419. unlockVideo(slot);           /* enable I/O to card      */
  420. VgaTextRegs = GenVgaTextRegs;
  422. switch (PCIVendor(slot)) {
  423. default:
  424. break;
  425. case(S3Vendor):
  426. unlockS3();
  427. break;
  429. case(CirrusVendor):
  430. outw(0x3C4, 0x0612);       /* unlock ext regs */
  431. outw(0x3C4, 0x0700);       /* reset ext sequence mode */
  432. break;
  434. case(ParadiseVendor):                 /* IBM Portable 850 */
  435. outw(0x3ce, 0x0f05);      /* unlock pardise registers */
  436. outw(0x3c4, 0x0648);
  437. outw(0x3d4, 0x2985);
  438. outw(0x3d4, 0x34a6);
  439. outb(0x3ce, 0x0b);       /* disable linear addressing */
  440. outb(0x3cf, inb(0x3cf) & ~0x30);
  441. outw(0x3c4, 0x1400);
  442. outb(0x3ce, 0x0e);       /* disable 256 color mode */
  443. outb(0x3cf, inb(0x3cf) & ~0x01);
  444. outb(0xd00, 0xff);       /* enable auto-centering */
  445. if (!(inb(0xd01) & 0x03)) {
  446. outb(0x3d4, 0x33);
  447. outb(0x3d5, inb(0x3d5) & ~0x90);
  448. outb(0x3d4, 0x32);
  449. outb(0x3d5, inb(0x3d5) | 0x04);
  450. outw(0x3d4, 0x0250);
  451. outw(0x3d4, 0x07ba);
  452. outw(0x3d4, 0x0900);
  453. outw(0x3d4, 0x15e7);
  454. outw(0x3d4, 0x2a95);
  455. }
  456. outw(0x3d4, 0x34a0);
  457. break;
  459. #if 0 /* Untested - probably doesn't work */
  460. case(MatroxVendor):
  461. case(DiamondVendor):
  462. puts("VGA Chip Vendor ID: ");
  463. puthex(PCIVendor(slot));
  464. puts("n");
  465. mdelay(1000);
  466. #endif
  467. };
  469. outw(0x3C4, 0x0120);           /* disable video              */
  470. setTextRegs(VgaTextRegs);      /* initial register setup     */
  471. setTextCLUT(0);                /* load color lookup table    */
  472. loadFont(ISA_mem);             /* load font                  */
  473. setTextRegs(VgaTextRegs);      /* reload registers           */
  474. outw(0x3C4, 0x0100);           /* re-enable video            */
  475. clearVideoMemory();
  477. if (PCIVendor(slot) == S3Vendor) {
  478. outb(0x3c2, 0x63);                  /* MISC */
  479. } /* endif */
  481. #ifdef DEBUG
  482. printslots();
  483. mdelay(5000);
  484. #endif
  486. mdelay(1000); /* give time for the video monitor to come up */
  487.         }
  488. return (1);  /* 'CRT' I/O supported */
  489. }
  491. /*
  492.  * Write to VGA Attribute registers.
  493.  */
  494. void
  495. writeAttr(unsigned char index, unsigned char data, unsigned char videoOn)
  496. {
  497. unsigned char v;
  498. v = inb(0x3da);   /* reset attr. address toggle */
  499. if (videoOn)
  500. outb(0x3c0, (index & 0x1F) | 0x20);
  501. else
  502. outb(0x3c0, (index & 0x1F));
  503. outb(0x3c0, data);
  504. }
  506. void
  507. setTextRegs(struct VgaRegs *svp)
  508. {
  509. int i;
  511. /*
  512.  *  saved settings
  513.  */
  514. while( svp->io_port != ENDMK ) {
  515. outb(svp->io_port,   svp->io_index);
  516. outb(svp->io_port+1, svp->io_value);
  517. svp++;
  518. }
  520. outb(0x3c2, 0x67);  /* MISC */
  521. outb(0x3c6, 0xff);  /* MASK */
  523. for ( i = 0; i < 0x10; i++)
  524. writeAttr(i, AC[i], 0);  /* pallete */
  525. writeAttr(0x10, 0x0c, 0);    /* text mode */
  526. writeAttr(0x11, 0x00, 0);    /* overscan color (border) */
  527. writeAttr(0x12, 0x0f, 0);    /* plane enable */
  528. writeAttr(0x13, 0x08, 0);    /* pixel panning */
  529. writeAttr(0x14, 0x00, 1);    /* color select; video on  */
  530. }
  532. void
  533. setTextCLUT(int shift)
  534. {
  535. int i;
  537. outb(0x3C6, 0xFF);
  538. i = inb(0x3C7);
  539. outb(0x3C8, 0);
  540. i = inb(0x3C7);
  542. for ( i = 0; i < 256; i++) {
  543. outb(0x3C9, TextCLUT[i].r << shift);
  544. outb(0x3C9, TextCLUT[i].g << shift);
  545. outb(0x3C9, TextCLUT[i].b << shift);
  546. }
  547. }
  549. void
  550. loadFont(unsigned char *ISA_mem)
  551. {
  552. int i, j;
  553. unsigned char *font_page = (unsigned char *) &ISA_mem[0xA0000];
  555. outb(0x3C2, 0x67);
  556. /*
  557.  * Load font
  558.  */
  559. i = inb(0x3DA);  /* Reset Attr toggle */
  561. outb(0x3C0,0x30);
  562. outb(0x3C0, 0x01);      /* graphics mode */
  564. outw(0x3C4, 0x0001);    /* reset sequencer */
  565. outw(0x3C4, 0x0204);    /* write to plane 2 */
  566. outw(0x3C4, 0x0406);    /* enable plane graphics */
  567. outw(0x3C4, 0x0003);    /* reset sequencer */
  568. outw(0x3CE, 0x0402);    /* read plane 2 */
  569. outw(0x3CE, 0x0500);    /* write mode 0, read mode 0 */
  570. outw(0x3CE, 0x0605);    /* set graphics mode */
  572. for (i = 0;  i < sizeof(font);  i += 16) {
  573. for (j = 0;  j < 16;  j++) {
  574. __asm__ volatile("eieio");
  575. font_page[(2*i)+j] = font[i+j];
  576. }
  577. }
  578. }
  580. static void
  581. unlockS3(void)
  582. {
  583.         int s3_device_id;
  584. outw(0x3d4, 0x3848);
  585. outw(0x3d4, 0x39a5);
  586. outb(0x3d4, 0x2d);
  587. s3_device_id = inb(0x3d5) << 8;
  588. outb(0x3d4, 0x2e);
  589. s3_device_id |= inb(0x3d5);
  591. if (s3_device_id != 0x8812) {
  592. /* From the S3 manual */
  593. outb(0x46E8, 0x10);  /* Put into setup mode */
  594. outb(0x3C3, 0x10);
  595. outb(0x102, 0x01);   /* Enable registers */
  596. outb(0x46E8, 0x08);  /* Enable video */
  597. outb(0x3C3, 0x08);
  598. outb(0x4AE8, 0x00);
  600. #if 0
  601. outb(0x42E8, 0x80);  /* Reset graphics engine? */
  602. #endif
  604. outb(0x3D4, 0x38);  /* Unlock all registers */
  605. outb(0x3D5, 0x48);
  606. outb(0x3D4, 0x39);
  607. outb(0x3D5, 0xA5);
  608. outb(0x3D4, 0x40);
  609. outb(0x3D5, inb(0x3D5)|0x01);
  610. outb(0x3D4, 0x33);
  611. outb(0x3D5, inb(0x3D5)&~0x52);
  612. outb(0x3D4, 0x35);
  613. outb(0x3D5, inb(0x3D5)&~0x30);
  614. outb(0x3D4, 0x3A);
  615. outb(0x3D5, 0x00);
  616. outb(0x3D4, 0x53);
  617. outb(0x3D5, 0x00);
  618. outb(0x3D4, 0x31);
  619. outb(0x3D5, inb(0x3D5)&~0x4B);
  620. outb(0x3D4, 0x58);
  622. outb(0x3D5, 0);
  624. outb(0x3D4, 0x54);
  625. outb(0x3D5, 0x38);
  626. outb(0x3D4, 0x60);
  627. outb(0x3D5, 0x07);
  628. outb(0x3D4, 0x61);
  629. outb(0x3D5, 0x80);
  630. outb(0x3D4, 0x62);
  631. outb(0x3D5, 0xA1);
  632. outb(0x3D4, 0x69);  /* High order bits for cursor address */
  633. outb(0x3D5, 0);
  635. outb(0x3D4, 0x32);
  636. outb(0x3D5, inb(0x3D5)&~0x10);
  637. } else {
  638.                 outw(0x3c4, 0x0806);            /* IBM Portable 860 */
  639.                 outw(0x3c4, 0x1041);
  640.                 outw(0x3c4, 0x1128);
  641.                 outw(0x3d4, 0x4000);
  642.                 outw(0x3d4, 0x3100);
  643.                 outw(0x3d4, 0x3a05);
  644.                 outw(0x3d4, 0x6688);
  645.                 outw(0x3d4, 0x5800);            /* disable linear addressing */
  646.                 outw(0x3d4, 0x4500);            /* disable H/W cursor */
  647.                 outw(0x3c4, 0x5410);            /* enable auto-centering */
  648.                 outw(0x3c4, 0x561f);
  649.                 outw(0x3c4, 0x1b80);            /* lock DCLK selection */
  650.                 outw(0x3d4, 0x3900);            /* lock S3 registers */
  651.                 outw(0x3d4, 0x3800);
  652. } /* endif */
  653. }
  655. /*
  656.  * cursor() sets an offset (0-1999) into the 80x25 text area.
  657.  */
  658. void
  659. cursor(int x, int y)
  660. {
  661. int pos = (y*cols)+x;
  662. outb(0x3D4, 14);
  663. outb(0x3D5, pos >> 8);
  664. outb(0x3D4, 15);
  665. outb(0x3D5, pos);
  666. }
  668. void
  669. clearVideoMemory(void)
  670. {
  671. int i, j;
  672. for (i = 0;  i < lines;  i++) {
  673. for (j = 0;  j < cols;  j++) {
  674. vidmem[((i*cols)+j)*2] = 0x20; /* fill with space character */
  675. vidmem[((i*cols)+j)*2+1] = 0x07;  /* set bg & fg attributes */
  676. }
  677. }
  678. }
  680. /* ============ */
  683. #define NSLOTS 8
  684. #define NPCIREGS  5
  687. /*
  688.  should use devfunc number/indirect method to be totally safe on
  689.  all machines, this works for now on 3 slot Moto boxes
  690. */
  692. struct PCI_ConfigInfo {
  693.   unsigned long * config_addr;
  694.   unsigned long regs[NPCIREGS];
  695. } PCI_slots [NSLOTS] = {
  697.     { (unsigned long *)0x80808000, 0xDEADBEEF },   /* onboard */
  698.     { (unsigned long *)0x80800800, 0xDEADBEEF },   /* onboard */
  699.     { (unsigned long *)0x80801000, 0xDEADBEEF },   /* onboard */
  700.     { (unsigned long *)0x80802000, 0xDEADBEEF },   /* onboard */
  701.     { (unsigned long *)0x80804000, 0xDEADBEEF },   /* onboard */
  702.     { (unsigned long *)0x80810000, 0xDEADBEEF },   /* slot A/1 */
  703.     { (unsigned long *)0x80820000, 0xDEADBEEF },   /* slot B/2 */
  704.     { (unsigned long *)0x80840000, 0xDEADBEEF }    /* slot C/3 */
  705. };
  709. /*
  710.  * The following code modifies the PCI Command register
  711.  * to enable memory and I/O accesses.
  712.  */
  713. void
  714. unlockVideo(int slot)
  715. {
  716.        volatile unsigned char * ppci;
  718.         ppci =  (unsigned char * )PCI_slots[slot].config_addr;
  719. ppci[4] = 0x0003;         /* enable memory and I/O accesses */
  720. ppci[0x10] = 0x00000;     /* turn off memory mapping */
  721. ppci[0x11] = 0x00000;     /* mem_base = 0 */
  722. ppci[0x12] = 0x00000;
  723. ppci[0x13] = 0x00000;
  724. __asm__ volatile("eieio");
  726. outb(0x3d4, 0x11);
  727. outb(0x3d5, 0x0e);   /* unlock CR0-CR7 */
  728. }
  730. long
  731. SwapBytes(long lv)   /* turn little endian into big indian long */
  732. {
  733.     long t;
  734.     t  = (lv&0x000000FF) << 24;
  735.     t |= (lv&0x0000FF00) << 8;
  736.     t |= (lv&0x00FF0000) >> 8;
  737.     t |= (lv&0xFF000000) >> 24;
  738.     return(t);
  739. }
  742. #define DEVID   0
  743. #define CMD     1
  744. #define CLASS   2
  745. #define MEMBASE 4
  747. int
  748. scanPCI(int start_slt)
  749. {
  750. int slt, r;
  751. struct PCI_ConfigInfo *pslot;
  752. int theSlot = -1;
  753. int highVgaSlot = 0;
  755. for ( slt = start_slt + 1; slt < NSLOTS; slt++) {
  756. pslot = &PCI_slots[slt];
  757. for ( r = 0; r < NPCIREGS; r++) {
  758. pslot->regs[r] = SwapBytes ( pslot->config_addr[r] );
  759. }
  760. /* card in slot ? */
  761. if ( pslot->regs[DEVID] != 0xFFFFFFFF ) {
  762. /* VGA ? */
  763. if ( ((pslot->regs[CLASS] & 0xFFFFFF00) == 0x03000000) ||
  764.      ((pslot->regs[CLASS] & 0xFFFFFF00) == 0x00010000)) {
  765. highVgaSlot = slt;
  766. /* did firmware enable it ? */
  767. if ( (pslot->regs[CMD] & 0x03) ) {
  768. theSlot = slt;
  769. break;
  770. }
  771. }
  772. }
  773. }
  775. return ( theSlot );
  776. }
  778. /* return Vendor ID of card in the slot */
  779. static
  780. int PCIVendor(int slotnum) {
  781.  struct PCI_ConfigInfo *pslot;
  783.  pslot = &PCI_slots[slotnum];
  785. return (pslot->regs[DEVID] & 0xFFFF);
  786. }
  788. #ifdef DEBUG
  789. static
  790. void printslots(void)
  791. {
  792. int i;
  793. #if 0
  794. struct PCI_ConfigInfo *pslot;
  795. #endif
  796. for(i=0; i < NSLOTS; i++) {
  797. #if 0
  798. pslot = &PCI_slots[i];
  799. printf("Slot: %d, Addr: %x, Vendor: %08x, Class: %08xn",
  800.        i, pslot->config_addr, pslot->regs[0], pslot->regs[2]);
  801. #else
  802. puts("PCI Slot number: "); puthex(i);
  803. puts(" Vendor ID: ");
  804. puthex(PCIVendor(i)); puts("n");
  805. #endif
  806. }
  807. }
  808. #endif /* DEBUG */