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

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

嵌入式Linux

开发平台：

Unix_Linux

sticon-bmode.c：源码内容
  1. /*
  2. TPG CVS users: please don't commit changes to this file directly, send
  3. them to prumpf@tux.org and wait for a new version instead.  Otherwise,
  4. your changes will get lost when prumpf releases the next version, as
  5. this file *will* be replaced with it.  You have been warned.
  7. 2000-05-30, <deller@gmx.de>
  8. */
  9. #if 1
  10. #define DPRINTK(x) printk x
  11. #else
  12. #define DPRINTK(x)
  13. #endif
  15. /*
  16.  *  linux/drivers/video/sticon.c  - console driver using HP's STI firmware
  17.  *
  18.  * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
  19.  *
  20.  *  Based on linux/drivers/video/vgacon.c and linux/drivers/video/fbcon.c,
  21.  *  which were
  22.  *
  23.  * Created 28 Sep 1997 by Geert Uytterhoeven
  24.  * Rewritten by Martin Mares <mj@ucw.cz>, July 1998
  25.  * Copyright (C) 1991, 1992  Linus Torvalds
  26.  *     1995  Jay Estabrook
  27.  * Copyright (C) 1995 Geert Uytterhoeven
  28.  * Copyright (C) 1993 Bjoern Brauel
  29.  *    Roman Hodek
  30.  * Copyright (C) 1993 Hamish Macdonald
  31.  *    Greg Harp
  32.  * Copyright (C) 1994 David Carter [carter@compsci.bristol.ac.uk]
  33.  *
  34.  *       with work by William Rucklidge (wjr@cs.cornell.edu)
  35.  *    Geert Uytterhoeven
  36.  *    Jes Sorensen (jds@kom.auc.dk)
  37.  *    Martin Apel
  38.  *       with work by Guenther Kelleter
  39.  *    Martin Schaller
  40.  *    Andreas Schwab
  41.  *    Emmanuel Marty (core@ggi-project.org)
  42.  *    Jakub Jelinek (jj@ultra.linux.cz)
  43.  *    Martin Mares <mj@ucw.cz>
  44.  *
  45.  *  This file is subject to the terms and conditions of the GNU General Public
  46.  *  License.  See the file COPYING in the main directory of this archive for
  47.  *  more details.
  48.  */
  49. /*
  50.  *  TODO:
  51.  *   - call STI in virtual mode rather than in real mode
  52.  *   - support for PCI-only STI ROMs (which don't have a traditional region
  53.  *     list)
  54.  *   - safe detection (i.e. verify there is a graphics device at a given
  55.  *     address first, not just read a random device's io space)
  56.  *   - support for multiple STI devices in one machine
  57.  *   - support for byte-mode STI ROMs
  58.  *   - support for just using STI to switch to a colour fb (stifb ?)
  59.  *   - try to make it work on m68k hp workstations ;)
  60.  */
  62. #include <linux/types.h>
  63. #include <linux/sched.h>
  64. #include <linux/fs.h>
  65. #include <linux/kernel.h>
  66. #include <linux/tty.h>
  67. #include <linux/console.h>
  68. #include <linux/string.h>
  69. #include <linux/kd.h>
  70. #include <linux/slab.h>
  71. #include <linux/vt_kern.h>
  72. #include <linux/selection.h>
  73. #include <linux/ioport.h>
  74. #include <linux/init.h>
  75. #include <linux/delay.h>
  77. #include <asm/io.h>
  78. #include <asm/real.h>
  80. #include <linux/module.h>
  81. #include <linux/fb.h>
  82. #include <linux/smp.h>
  84. #include <asm/irq.h>
  85. #include <asm/system.h>
  86. #include <asm/uaccess.h>
  88. #include <video/fbcon.h>
  89. #include <video/font.h>
  91. #include "sti-bmode.h"
  93. /* The latency of the STI functions cannot really be reduced by setting
  94.  * this to 0;  STI doesn't seem to be designed to allow calling a different
  95.  * function (or the same function with different arguments) after a
  96.  * function exited with 1 as return value.
  97.  *
  98.  * As all of the functions below could be called from interrupt context,
  99.  * we have to spin_lock_irqsave around the do { ret = bla(); } while(ret==1)
  100.  * block.  Really bad latency there.
  101.  *
  102.  * Probably the best solution to all this is have the generic code manage
  103.  * the screen buffer and a kernel thread to call STI occasionally.
  104.  * 
  105.  * Luckily, the frame buffer guys have the same problem so we can just wait
  106.  * for them to fix it and steal their solution.   prumpf
  107.  *
  108.  * Actually, another long-term viable solution is to completely do STI
  109.  * support in userspace - that way we avoid the potential license issues
  110.  * of using proprietary fonts, too. */
  111.  
  112. #define STI_WAIT 1
  113. #define STI_PTR(p) ( (typeof(p)) virt_to_phys(p))
  114. #define PTR_STI(p) ( (typeof(p)) phys_to_virt((unsigned long)p) )
  116. static struct sti_struct default_sti = {
  117. SPIN_LOCK_UNLOCKED,
  118. };
  120. static struct sti_font_flags default_font_flags = {
  121. STI_WAIT, 0, 0, NULL
  122. };
  124. /* The colour indices used by STI are
  125.  *   0 - Black
  126.  *   1 - White
  127.  *   2 - Red
  128.  *   3 - Yellow/Brown
  129.  *   4 - Green
  130.  *   5 - Cyan
  131.  *   6 - Blue
  132.  *   7 - Magenta
  133.  *
  134.  * So we have the same colours as VGA (basically one bit each for R, G, B),
  135.  * but have to translate them, anyway. */
  137. static u8 col_trans[8] = {
  138.         0, 6, 4, 5,
  139.         2, 7, 3, 1
  140. };
  142. #define c_fg(sti, c) col_trans[((c>> 8) & 7)]
  143. #define c_bg(sti, c) col_trans[((c>>11) & 7)]
  144. #define c_index(sti, c) (c&0xff)
  146. #define sti_onscreen_x(sti) (PTR_STI(sti->glob_cfg)->onscreen_x)
  147. #define sti_onscreen_y(sti) (PTR_STI(sti->glob_cfg)->onscreen_y)
  148. #define sti_font_x(sti) (STI_U8(PTR_STI(sti->font)->width))
  149. #define sti_font_y(sti) (STI_U8(PTR_STI(sti->font)->height))
  151. static struct sti_init_flags default_init_flags = {
  152. STI_WAIT, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, NULL
  153. };
  155. static void sti_init_graph(struct sti_struct *sti) 
  156. {
  157. struct sti_init_inptr_ext inptr_ext = {
  158. 0, { 0 }, 0, NULL
  159. };
  160. struct sti_init_inptr inptr = {
  161. 3, STI_PTR(&inptr_ext)
  162. };
  163. struct sti_init_outptr outptr = { 0 };
  164. unsigned long flags;
  165. s32 ret;
  167. spin_lock_irqsave(&sti->lock, flags);
  169. ret = STI_CALL(sti->init_graph, &default_init_flags, &inptr,
  170. &outptr, sti->glob_cfg);
  172. spin_unlock_irqrestore(&sti->lock, flags);
  174. sti->text_planes = outptr.text_planes;
  175. }
  177. #if 0
  178. static struct sti_conf_flags default_conf_flags = {
  179. STI_WAIT, 0, NULL
  180. };
  182. static void sti_inq_conf(struct sti_struct *sti)
  183. {
  184. struct sti_conf_inptr inptr = { NULL };
  185. struct sti_conf_outptr_ext outptr_ext = { future_ptr: NULL };
  186. struct sti_conf_outptr outptr = {
  187. ext_ptr: STI_PTR(&outptr_ext)
  188. };
  189. unsigned long flags;
  190. s32 ret;
  192. do {
  193. spin_lock_irqsave(&sti->lock, flags);
  194. ret = STI_CALL(sti->inq_conf, &default_conf_flags,
  195. &inptr, &outptr, sti->glob_cfg);
  196. spin_unlock_irqrestore(&sti->lock, flags);
  197. } while(ret == 1);
  198. }
  199. #endif
  201. static void sti_putc(struct sti_struct *sti, int c, int y, int x)
  202. {
  203. struct sti_font_inptr inptr = {
  204. (u32) sti->font, c_index(sti, c), c_fg(sti, c), c_bg(sti, c),
  205. x * sti_font_x(sti), y * sti_font_y(sti), NULL
  206. };
  207. struct sti_font_outptr outptr = {
  208. 0, NULL
  209. };
  210. s32 ret;
  211. unsigned long flags;
  213. do {
  214. spin_lock_irqsave(&sti->lock, flags);
  215. ret = STI_CALL(sti->font_unpmv, &default_font_flags,
  216. &inptr, &outptr, sti->glob_cfg);
  217. spin_unlock_irqrestore(&sti->lock, flags);
  218. } while(ret == 1);
  219. }
  221. static struct sti_blkmv_flags clear_blkmv_flags = {
  222. STI_WAIT, 1, 1, 0, 0, NULL
  223. };
  225. static void sti_set(struct sti_struct *sti, int src_y, int src_x,
  226. int height, int width, u8 color)
  227. {
  228. struct sti_blkmv_inptr inptr = {
  229. color, color,
  230. src_x, src_y ,
  231. src_x, src_y ,
  232. width, height,
  233. NULL
  234. };
  235. struct sti_blkmv_outptr outptr = { 0, NULL };
  236. s32 ret = 0;
  237. unsigned long flags;
  239. do {
  240. spin_lock_irqsave(&sti->lock, flags);
  241. ret = STI_CALL(sti->block_move, &clear_blkmv_flags,
  242. &inptr, &outptr, sti->glob_cfg);
  243. spin_unlock_irqrestore(&sti->lock, flags);
  244. } while(ret == 1);
  245. }
  247. static void sti_clear(struct sti_struct *sti, int src_y, int src_x,
  248. int height, int width)
  249. {
  250. struct sti_blkmv_inptr inptr = {
  251. 0, 0,
  252. src_x * sti_font_x(sti), src_y * sti_font_y(sti),
  253. src_x * sti_font_x(sti), src_y * sti_font_y(sti),
  254. width * sti_font_x(sti), height* sti_font_y(sti),
  255. NULL
  256. };
  257. struct sti_blkmv_outptr outptr = { 0, NULL };
  258. s32 ret = 0;
  259. unsigned long flags;
  261. do {
  262. spin_lock_irqsave(&sti->lock, flags);
  263. ret = STI_CALL(sti->block_move, &clear_blkmv_flags,
  264. &inptr, &outptr, sti->glob_cfg);
  265. spin_unlock_irqrestore(&sti->lock, flags);
  266. } while(ret == 1);
  267. }
  269. static struct sti_blkmv_flags default_blkmv_flags = {
  270. STI_WAIT, 0, 0, 0, 0, NULL
  271. };
  273. static void sti_bmove(struct sti_struct *sti, int src_y, int src_x,
  274. int dst_y, int dst_x, int height, int width)
  275. {
  276. struct sti_blkmv_inptr inptr = {
  277. 0, 0,
  278. src_x * sti_font_x(sti), src_y * sti_font_y(sti),
  279. dst_x * sti_font_x(sti), dst_y * sti_font_y(sti),
  280. width * sti_font_x(sti), height* sti_font_y(sti),
  281. NULL
  282. };
  283. struct sti_blkmv_outptr outptr = { 0, NULL };
  284. s32 ret = 0;
  285. unsigned long flags;
  287. do {
  288. spin_lock_irqsave(&sti->lock, flags);
  289. ret = STI_CALL(sti->block_move, &default_blkmv_flags,
  290. &inptr, &outptr, sti->glob_cfg);
  291. spin_unlock_irqrestore(&sti->lock, flags);
  292. } while(ret == 1);
  293. }
  296. /* STICON */
  298. static const char __init *sticon_startup(void)
  299. {
  300. return "STI console";
  301. }
  303. static int sticon_set_palette(struct vc_data *c, unsigned char *table)
  304. {
  305. return -EINVAL;
  306. }
  307. static int sticon_font_op(struct vc_data *c, struct console_font_op *op)
  308. {
  309. return -ENOSYS;
  310. }
  312. static void sticon_putc(struct vc_data *conp, int c, int ypos, int xpos)
  313. {
  314. sti_putc(&default_sti, c, ypos, xpos);
  315. }
  317. static void sticon_putcs(struct vc_data *conp, const unsigned short *s,
  318. int count, int ypos, int xpos)
  319. {
  320. while(count--) {
  321. sti_putc(&default_sti, scr_readw(s++), ypos, xpos++);
  322. }
  323. }
  325. static void sticon_cursor(struct vc_data *conp, int mode)
  326. {
  327. }
  329. static int sticon_scroll(struct vc_data *conp, int t, int b, int dir,
  330. int count)
  331. {
  332. struct sti_struct *sti = &default_sti;
  334. if(console_blanked)
  335. return 0;
  337. sticon_cursor(conp, CM_ERASE);
  339. switch(dir) {
  340. case SM_UP:
  341. sti_bmove(sti, t+count, 0, t, 0, b-t-count, conp->vc_cols);
  342. sti_clear(sti, b-count, 0, count, conp->vc_cols);
  344. break;
  346. case SM_DOWN:
  347. sti_bmove(sti, t, 0, t+count, 0, b-t-count, conp->vc_cols);
  348. sti_clear(sti, t, 0, count, conp->vc_cols);
  350. break;
  351. }
  353. return 0;
  354. }
  356. static void sticon_bmove(struct vc_data *conp, int sy, int sx, int dy, int dx,
  357. int height, int width)
  358. {
  359. sti_bmove(&default_sti, sy, sx, dy, dx, height, width);
  360. }
  362. static void sticon_init(struct vc_data *c, int init)
  363. {
  364. struct sti_struct *sti = &default_sti;
  365. int vc_cols, vc_rows;
  367. sti_set(sti, 0, 0, sti_onscreen_y(sti), sti_onscreen_x(sti), 0);
  368. c->vc_can_do_color = 1;
  369. vc_cols = PTR_STI(sti->glob_cfg)->onscreen_x / sti_font_x(sti);
  370. vc_rows = PTR_STI(sti->glob_cfg)->onscreen_y / sti_font_y(sti);
  372. vc_resize_con(vc_rows, vc_cols, c->vc_num);
  373. }
  375. static void sticon_deinit(struct vc_data *c)
  376. {
  377. }
  379. static void sticon_clear(struct vc_data *conp, int sy, int sx, int height,
  380. int width)
  381. {
  382. sti_clear(&default_sti, sy, sx, height, width);
  383. }
  385. static int sticon_switch(struct vc_data *conp)
  386. {
  387. return 0;
  388. }
  390. static int sticon_blank(struct vc_data *conp, int blank)
  391. {
  392. return 0;
  393. }
  395. static int sticon_scrolldelta(struct vc_data *conp, int lines)
  396. {
  397. return 0;
  398. }
  400. static int sticon_set_origin(struct vc_data *conp)
  401. {
  402. return 0;
  403. }
  405. static u8 sticon_build_attr(struct vc_data *conp, u8 color, u8 intens, u8 blink, u8 underline, u8 reverse)
  406. {
  407. u8 attr = ((color & 0x70) >> 1) | ((color & 7));
  409. if(reverse) {
  410. color = ((color>>3)&0x7) | ((color &0x7)<<3);
  411. }
  414. return attr;
  415. }
  417. static struct consw sti_con = {
  418. con_startup:  sticon_startup, 
  419. con_init:  sticon_init,
  420. con_deinit:  sticon_deinit,
  421. con_clear:  sticon_clear,
  422. con_putc:  sticon_putc,
  423. con_putcs:  sticon_putcs,
  424. con_cursor:  sticon_cursor,
  425. con_scroll:  sticon_scroll,
  426. con_bmove:  sticon_bmove,
  427. con_switch:  sticon_switch,
  428. con_blank:  sticon_blank,
  429. con_font_op: sticon_font_op,
  430. con_set_palette: sticon_set_palette,
  431. con_scrolldelta: sticon_scrolldelta,
  432. con_set_origin:  sticon_set_origin,
  433. con_build_attr: sticon_build_attr,
  434. };
  436. #include <asm/pgalloc.h> /* need cache flush routines */
  437. static void __init sti_rom_copy(unsigned long base, unsigned long offset,
  438. unsigned long count, void *dest)
  439. {
  440. void *savedest = dest;
  441. int savecount = count;
  443. while(count >= 4) {
  444. count -= 4;
  445. *(u32 *)dest = gsc_readl(base + offset);
  446. #if 0
  447. DPRINTK(("%08xn", *(u32 *)dest));
  448. if(*(u32 *)dest == 0x64646464) {
  449.   DPRINTK(("!!!!n"));
  450.   { u32 foo = 0; while(foo += 0x100); }
  451. }
  452. #endif
  453. offset += 4;
  454. dest += 4;
  455. }
  456. while(count) {
  457. count--;
  458. *(u8 *)dest = gsc_readb(base + offset);
  459. offset++;
  460. dest++;
  461. }
  463. flush_kernel_dcache_range((unsigned long)dest, count);
  464. flush_icache_range((unsigned long)dest, dest + count);
  465. }
  467. static void dump_sti_rom(struct sti_rom *rom)
  468. {
  469. printk("STI byte mode ROM type %dn", STI_U8(rom->type));
  470. printk(" supports %d monitorsn", STI_U8(rom->num_mons));
  471. printk(" conforms to STI ROM spec revision %d.%02xn",
  472. STI_U8(rom->revno[0]) >> 4, STI_U8(rom->revno[0]) & 0x0f);
  473. printk(__FUNCTION__ ": %dn", __LINE__);
  474. printk(" graphics id %02x%02x%02x%02x%02x%02x%02x%02xn",
  475. (unsigned int) STI_U8(rom->graphics_id[0]), 
  476. (unsigned int) STI_U8(rom->graphics_id[1]), 
  477. (unsigned int) STI_U8(rom->graphics_id[2]), 
  478. (unsigned int) STI_U8(rom->graphics_id[3]), 
  479. (unsigned int) STI_U8(rom->graphics_id[4]), 
  480. (unsigned int) STI_U8(rom->graphics_id[5]), 
  481. (unsigned int) STI_U8(rom->graphics_id[6]), 
  482. (unsigned int) STI_U8(rom->graphics_id[7]));
  483. printk(__FUNCTION__ ": %dn", __LINE__);
  484. printk(" font start %08xn",  STI_U32(rom->font_start));
  485. printk(__FUNCTION__ ": %dn", __LINE__);
  486. printk(" region list %08xn", STI_U32(rom->region_list));
  487. printk(__FUNCTION__ ": %dn", __LINE__);
  488. printk(" init_graph %08xn",  STI_U32(rom->init_graph));
  489. printk(__FUNCTION__ ": %dn", __LINE__);
  490. printk(" alternate code type %dn", STI_U8(rom->alt_code_type));
  491. printk(__FUNCTION__ ": %dn", __LINE__);
  492. }
  494. static void __init sti_cook_fonts(struct sti_cooked_rom *cooked_rom,
  495.   struct sti_rom *raw_rom)
  496. {
  497. struct sti_rom_font *raw_font;
  498. struct sti_cooked_font *cooked_font;
  499. struct sti_rom_font *font_start;
  501. cooked_font =
  502. kmalloc(sizeof *cooked_font, GFP_KERNEL);
  503. if(!cooked_font)
  504. return;
  506. cooked_rom->font_start = cooked_font;
  508. #if 0
  509. DPRINTK(("%p = %p + %08xn",
  510.        ((void *)raw_rom) + (STI_U32(raw_rom->font_start)),
  511.        ((void *)raw_rom), (STI_U32(raw_rom->font_start))));
  512. #endif
  513. raw_font = ((void *)raw_rom) + STI_U32(raw_rom->font_start) - 3;
  515. font_start = raw_font;
  516. cooked_font->raw = raw_font;
  518. DPRINTK(("next font %08xn", STI_U32(raw_font->next_font)));
  520. while(0 && STI_U32(raw_font->next_font)) {
  521. raw_font = ((void *)font_start) + STI_U32(raw_font->next_font);
  523. cooked_font->next_font =
  524. kmalloc(sizeof *cooked_font, GFP_KERNEL);
  525. if(!cooked_font->next_font)
  526. return;
  528. cooked_font = cooked_font->next_font;
  530. // cooked_font->raw = raw_font;
  532. DPRINTK(("raw_font %pn",
  533.        raw_font));
  534. DPRINTK(("next_font %08x %pn",
  535.        STI_U32(raw_font->next_font),
  536.        ((void *)font_start) + STI_U32(raw_font->next_font)));
  537. }
  539. cooked_font->next_font = NULL;
  540. }
  542. static unsigned long __init sti_cook_function(void *function,
  543.       u32 size)
  544. {
  545. sti_u32 *func = (sti_u32 *)function;
  546. u32 *ret;
  547. int i;
  549. ret = kmalloc(size, GFP_KERNEL);
  550. if(!ret) {
  551. printk(KERN_ERR __FILE__ ": could not get memory.n");
  552. return 0;
  553. }
  555. for(i=0; i<(size/4); i++)
  556.     ret[i] = STI_U32(func[i]);
  558. flush_all_caches();
  560. return virt_to_phys(ret);
  561. }
  563. static int font_index, font_height, font_width;
  565. static int __init sti_search_font(struct sti_cooked_rom *rom,
  566.   int height, int width)
  567. {
  568. struct sti_cooked_font *font;
  569. int i = 0;
  571. for(font = rom->font_start; font; font = font->next_font, i++) {
  572. if((STI_U8(font->raw->width) == width) &&
  573.    (STI_U8(font->raw->height) == height))
  574. return i;
  575. }
  577. return 0;
  578. }
  580. static struct sti_cooked_font * __init
  581. sti_select_font(struct sti_cooked_rom *rom)
  582. {
  583. struct sti_cooked_font *font;
  584. int i;
  586. if(font_width && font_height)
  587. font_index = sti_search_font(rom, font_height, font_width);
  589. for(font = rom->font_start, i = font_index;
  590.     font && (i > 0);
  591.     font = font->next_font, i--);
  593. if(font)
  594. return font;
  595. else
  596. return rom->font_start;
  597. }
  599. /* address is a pointer to a word mode or pci rom */
  600. static struct sti_struct * __init sti_read_rom(unsigned long address)
  601. {
  602. struct sti_struct *ret = NULL;
  603. struct sti_cooked_rom *cooked = NULL;
  604. struct sti_rom *raw = NULL;
  605. unsigned long size;
  607. ret = &default_sti;
  609. if(!ret)
  610. goto out_err;
  612. cooked = kmalloc(sizeof *cooked, GFP_KERNEL);
  613. raw = kmalloc(sizeof *raw, GFP_KERNEL);
  615. if(!(raw && cooked))
  616. goto out_err;
  618. /* reallocate raw */
  619. sti_rom_copy(address, 0, sizeof *raw, raw);
  621. dump_sti_rom(raw);
  623. size = STI_U32(raw->last_addr) + 1;
  624. size = 128*1024;
  625. // DPRINTK(("size %08lxn", size));
  626. // DPRINTK(("font_start %08xn", STI_U32(raw->font_start)));
  627. // kfree(raw);
  628. raw = kmalloc(size, GFP_KERNEL);
  629. if(!raw)
  630. goto out_err;
  631. sti_rom_copy(address, 0, size-1, raw);
  633. sti_cook_fonts(cooked, raw);
  634. // sti_cook_regions(cooked, raw);
  635. // sti_cook_functions(cooked, raw);
  637. if(STI_U32(raw->region_list)) {
  638. struct sti_rom_region *region =
  639. ((void *)raw) + STI_U32(raw->region_list) - 3;
  641. // DPRINTK(("region_list %08xn", STI_U32(raw->region_list)));
  643. ret->regions = kmalloc(32, GFP_KERNEL); /* FIXME!! */
  645. ret->regions[0] = STI_U32(region[0].region);
  646. ret->regions[1] = STI_U32(region[1].region);
  647. ret->regions[2] = STI_U32(region[2].region);
  648. ret->regions[3] = STI_U32(region[3].region);
  649. ret->regions[4] = STI_U32(region[4].region);
  650. ret->regions[5] = STI_U32(region[5].region);
  651. ret->regions[6] = STI_U32(region[6].region);
  652. ret->regions[7] = STI_U32(region[7].region);
  653. }
  655. address = virt_to_phys(raw);
  657. #if 0
  658. DPRINTK(("init_graph %08x %08xn"
  659.        "state_mgmt %08x %08xn"
  660.        "font_unpmv %08x %08xn"
  661.        "block_move %08x %08xn"
  662.        "self_test  %08x %08xn"
  663.        "excep_hdlr %08x %08xn"
  664.        "irq_conf   %08x %08xn"
  665.        "set_cm_e   %08x %08xn"
  666.        "dma_ctrl   %08x %08xn"
  667.        "flow_ctrl  %08x %08xn"
  668.        "user_timin %08x %08xn"
  669.        "process_m  %08x %08xn"
  670.        "sti_util   %08x %08xn"
  671.        "end_addr   %08x %08xn",
  672.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  673.        STI_U32(raw->state_mgmt), STI_U32(raw->state_mgmt_m68k),
  674.        STI_U32(raw->font_unpmv), STI_U32(raw->font_unpmv_m68k),
  675.        STI_U32(raw->block_move), STI_U32(raw->block_move_m68k),
  676.        STI_U32(raw->self_test), STI_U32(raw->self_test_m68k),
  677.        STI_U32(raw->excep_hdlr), STI_U32(raw->excep_hdlr_m68k),
  678.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  679.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  680.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  681.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  682.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  683.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  684.        STI_U32(raw->init_graph), STI_U32(raw->init_graph_m68k),
  685.        STI_U32(raw->end_addr), STI_U32(raw->end_addr_m68k) ) );
  686. #endif
  688. ret->init_graph = sti_cook_function(((void *)raw)+STI_U32(raw->init_graph)-3,
  689.     (STI_U32(raw->state_mgmt) -
  690.      STI_U32(raw->init_graph))/4);
  693. ret->font_unpmv = sti_cook_function(((void *)raw)+STI_U32(raw->font_unpmv)-3,
  694.     (STI_U32(raw->block_move) -
  695.      STI_U32(raw->font_unpmv))/4);
  697. ret->block_move = sti_cook_function(((void *)raw)+STI_U32(raw->block_move)-3,
  698.     (STI_U32(raw->self_test) -
  699.      STI_U32(raw->block_move))/4);
  701. ret->inq_conf = sti_cook_function(((void *)raw)+STI_U32(raw->inq_conf),
  702.   STI_U32(raw->set_cm_entry) -
  703.   STI_U32(raw->inq_conf));
  705. ret->rom = cooked;
  706. ret->rom->raw = raw;
  708. ret->font = (struct sti_rom_font *) virt_to_phys(sti_select_font(ret->rom)->raw);
  710. return ret;
  712. out_err:
  713. if(raw)
  714. kfree(raw);
  715. if(cooked)
  716. kfree(cooked);
  718. return NULL;
  719. }
  721. #if 0
  722. static void dump_globcfg_ext(struct sti_glob_cfg_ext *cfg)
  723. {
  724. DPRINTK(("monitor %dn"
  725. "in friendly mode: %dn"
  726. "power consumption %d wattsn"
  727. "freq ref %dn"
  728. "sti_mem_addr %pn",
  729. cfg->curr_mon,
  730. cfg->friendly_boot,
  731. cfg->power,
  732. cfg->freq_ref,
  733. cfg->sti_mem_addr));
  734. }
  736. static void dump_globcfg(struct sti_glob_cfg *glob_cfg)
  737. {
  738. DPRINTK(("%d text planesn"
  739. "%4d x %4d screen resolutionn"
  740. "%4d x %4d offscreenn"
  741. "%4d x %4d layoutn"
  742. "regions at %08x %08x %08x %08xn"
  743. "regions at %08x %08x %08x %08xn"
  744. "reent_lvl %dn"
  745. "save_addr %pn",
  746. glob_cfg->text_planes,
  747. glob_cfg->onscreen_x, glob_cfg->onscreen_y,
  748. glob_cfg->offscreen_x, glob_cfg->offscreen_y,
  749. glob_cfg->total_x, glob_cfg->total_y,
  750. glob_cfg->region_ptrs[0], glob_cfg->region_ptrs[1],
  751. glob_cfg->region_ptrs[2], glob_cfg->region_ptrs[3],
  752. glob_cfg->region_ptrs[4], glob_cfg->region_ptrs[5],
  753. glob_cfg->region_ptrs[6], glob_cfg->region_ptrs[7],
  754. glob_cfg->reent_lvl,
  755. glob_cfg->save_addr));
  756. dump_globcfg_ext(PTR_STI(glob_cfg->ext_ptr));
  757. }
  758. #endif
  760. static void __init sti_init_glob_cfg(struct sti_struct *sti, unsigned long hpa,
  761.      unsigned long rom_address)
  762. {
  763. struct sti_glob_cfg *glob_cfg;
  764. struct sti_glob_cfg_ext *glob_cfg_ext;
  765. void *save_addr;
  766. void *sti_mem_addr;
  768. glob_cfg = kmalloc(sizeof *sti->glob_cfg, GFP_KERNEL);
  769. glob_cfg_ext = kmalloc(sizeof *glob_cfg_ext, GFP_KERNEL);
  770. save_addr = kmalloc(1024 /*XXX*/, GFP_KERNEL);
  771. sti_mem_addr = kmalloc(1024, GFP_KERNEL);
  773. if((!glob_cfg) || (!glob_cfg_ext) || (!save_addr) || (!sti_mem_addr))
  774. return;
  776. memset(glob_cfg, 0, sizeof *glob_cfg);
  777. memset(glob_cfg_ext, 0, sizeof *glob_cfg_ext);
  778. memset(save_addr, 0, 1024);
  779. memset(sti_mem_addr, 0, 1024);
  781. glob_cfg->ext_ptr = STI_PTR(glob_cfg_ext);
  782. glob_cfg->save_addr = STI_PTR(save_addr);
  783. glob_cfg->region_ptrs[0] = ((sti->regions[0]>>18)<<12) + rom_address;
  784. glob_cfg->region_ptrs[1] = ((sti->regions[1]>>18)<<12) + hpa;
  785. glob_cfg->region_ptrs[2] = ((sti->regions[2]>>18)<<12) + hpa;
  786. glob_cfg->region_ptrs[3] = ((sti->regions[3]>>18)<<12) + hpa;
  787. glob_cfg->region_ptrs[4] = ((sti->regions[4]>>18)<<12) + hpa;
  788. glob_cfg->region_ptrs[5] = ((sti->regions[5]>>18)<<12) + hpa;
  789. glob_cfg->region_ptrs[6] = ((sti->regions[6]>>18)<<12) + hpa;
  790. glob_cfg->region_ptrs[7] = ((sti->regions[7]>>18)<<12) + hpa;
  792. glob_cfg_ext->sti_mem_addr = STI_PTR(sti_mem_addr);
  794. sti->glob_cfg = STI_PTR(glob_cfg);
  795. }
  797. static void __init sti_try_rom(unsigned long address, unsigned long hpa)
  798. {
  799. struct sti_struct *sti = NULL;
  800. u16 sig;
  802. /* if we can't read the ROM, bail out early.  Not being able
  803.  * to read the hpa is okay, for romless sti */
  804. if(pdc_add_valid((void*)address))
  805. return;
  807. printk("found potential STI ROM at %08lxn", address);
  809. sig = le16_to_cpu(gsc_readw(address));
  811. if((sig&0xff) == 0x01) {
  812. sti = sti_read_rom(address);
  813. }
  815. if(sig == 0x0303) {
  816. printk("STI word mode ROM at %08lx, ignoredn",
  817.        address);
  819. sti = NULL;
  820. }
  822. if(!sti)
  823. return;
  825. /* this is hacked.  We need a better way to find out the HPA for
  826.  * romless STI (eg search for the graphics devices we know about
  827.  * by sversion) */
  828. if (!pdc_add_valid((void *)0xf5000000)) DPRINTK(("f4000000 bn"));
  829. if (!pdc_add_valid((void *)0xf7000000)) DPRINTK(("f6000000 bn"));
  830. if (!pdc_add_valid((void *)0xf9000000)) DPRINTK(("f8000000 bn"));
  831. if (!pdc_add_valid((void *)0xfb000000)) DPRINTK(("fa000000 bn"));
  832. sti_init_glob_cfg(sti, hpa, address);
  834. sti_init_graph(sti);
  836. //sti_inq_conf(sti);
  837. #if !defined(SERIAL_CONSOLE)
  838. { 
  839.     extern void pdc_console_die(void);  
  840.     pdc_console_die(); 
  841. }
  842. #endif
  844. take_over_console(&sti_con, 0, MAX_NR_CONSOLES-1, 1);
  846. /* sti_inq_conf(sti); */
  847. }
  849. static unsigned long sti_address;
  850. static unsigned long sti_hpa;
  852. static void __init sti_init_roms(void)
  853. {
  854. /* handle the command line */
  855. if(sti_address && sti_hpa) {
  856. sti_try_rom(sti_address, sti_hpa);
  858. return;
  859. }
  861. /* 712, 715, some other boxes don't have a separate STI ROM,
  862.  * but use part of the regular flash */
  863. if(PAGE0->proc_sti) {
  864. printk("STI ROM from PDC at %08xn", PAGE0->proc_sti);
  865. if(!pdc_add_valid((void *)0xf9000000))
  866. sti_try_rom(PAGE0->proc_sti, 0xf8000000);
  867. else if(!pdc_add_valid((void *)0xf5000000))
  868. sti_try_rom(PAGE0->proc_sti, 0xf4000000);
  869. else if(!pdc_add_valid((void *)0xf7000000))
  870. sti_try_rom(PAGE0->proc_sti, 0xf6000000);
  871. else if(!pdc_add_valid((void *)0xfb000000))
  872. sti_try_rom(PAGE0->proc_sti, 0xfa000000);
  873. }
  875. /* standard locations for GSC graphic devices */
  876. if(!pdc_add_valid((void *)0xf4000000))
  877. sti_try_rom(0xf4000000, 0xf4000000);
  878. if(!pdc_add_valid((void *)0xf6000000))
  879. sti_try_rom(0xf6000000, 0xf6000000);
  880. if(!pdc_add_valid((void *)0xf8000000))
  881. sti_try_rom(0xf8000000, 0xf8000000);
  882. if(!pdc_add_valid((void *)0xfa000000))
  883. sti_try_rom(0xfa000000, 0xfa000000);
  884. }
  886. static int __init sti_init(void)
  887. {
  888. printk("searching for byte mode STI ROMsn");
  889. sti_init_roms();
  890. return 0;
  891. }
  893. module_init(sti_init)
  895. MODULE_LICENSE("GPL");