drivers/video/sticore.c

   1 #include <linux/module.h>
   2 #include <linux/types.h>
   3 #include <linux/kernel.h>
   4 #include <linux/malloc.h>
   5 #include <linux/init.h>
   6
   7 #include <asm/uaccess.h>
   8 #include <asm/pgalloc.h>
   9 #include <asm/io.h>
  10
  11 #include "sti.h"
  12
  13 struct sti_struct default_sti = {
  14         SPIN_LOCK_UNLOCKED,
  15 };
  16
  17 static struct sti_font_flags default_font_flags = {
  18         STI_WAIT, 0, 0, NULL
  19 };
  20
  21 /* The colour indices used by STI are
  22  *   0 - Black
  23  *   1 - White
  24  *   2 - Red
  25  *   3 - Yellow/Brown
  26  *   4 - Green
  27  *   5 - Cyan
  28  *   6 - Blue
  29  *   7 - Magenta
  30  *
  31  * So we have the same colours as VGA (basically one bit each for R, G, B),
  32  * but have to translate them, anyway. */
  33
  34 static u8 col_trans[8] = {
  35         0, 6, 4, 5,
  36         2, 7, 3, 1
  37 };
  38
  39 #define c_fg(sti, c) col_trans[((c>> 8) & 7)]
  40 #define c_bg(sti, c) col_trans[((c>>11) & 7)]
  41 #define c_index(sti, c) (c&0xff)
  42
  43 static struct sti_init_flags default_init_flags = {
  44         STI_WAIT, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, NULL
  45 };
  46
  47 void
  48 sti_init_graph(struct sti_struct *sti)
  49 {
  50         struct sti_init_inptr_ext inptr_ext = {
  51                 0, { 0 }, 0, NULL
  52         };
  53         struct sti_init_inptr inptr = {
  54                 3, STI_PTR(&inptr_ext)
  55         };
  56         struct sti_init_outptr outptr = { 0 };
  57         unsigned long flags;
  58         s32 ret;
  59
  60         spin_lock_irqsave(&sti->lock, flags);
  61
  62         ret = STI_CALL(sti->init_graph, &default_init_flags, &inptr,
  63                 &outptr, sti->glob_cfg);
  64
  65         spin_unlock_irqrestore(&sti->lock, flags);
  66
  67         sti->text_planes = outptr.text_planes;
  68 }
  69
  70 static struct sti_conf_flags default_conf_flags = {
  71         STI_WAIT, 0, NULL
  72 };
  73
  74 void
  75 sti_inq_conf(struct sti_struct *sti)
  76 {
  77         struct sti_conf_inptr inptr = { NULL };
  78         struct sti_conf_outptr_ext outptr_ext = { future_ptr: NULL };
  79         struct sti_conf_outptr outptr = {
  80                 ext_ptr: STI_PTR(&outptr_ext)
  81         };
  82         unsigned long flags;
  83         s32 ret;
  84
  85         do {
  86                 spin_lock_irqsave(&sti->lock, flags);
  87                 ret = STI_CALL(sti->inq_conf, &default_conf_flags,
  88                         &inptr, &outptr, sti->glob_cfg);
  89                 spin_unlock_irqrestore(&sti->lock, flags);
  90         } while(ret == 1);
  91 }
  92
  93 void
  94 sti_putc(struct sti_struct *sti, int c, int y, int x)
  95 {
  96         struct sti_font_inptr inptr = {
  97                 (u32) sti->font, c_index(sti, c), c_fg(sti, c), c_bg(sti, c),
  98                 x * sti_font_x(sti), y * sti_font_y(sti), NULL
  99         };
 100         struct sti_font_outptr outptr = {
 101                 0, NULL
 102         };
 103         s32 ret;
 104         unsigned long flags;
 105
 106         do {
 107                 spin_lock_irqsave(&sti->lock, flags);
 108                 ret = STI_CALL(sti->font_unpmv, &default_font_flags,
 109                         &inptr, &outptr, sti->glob_cfg);
 110                 spin_unlock_irqrestore(&sti->lock, flags);
 111         } while(ret == 1);
 112 }
 113
 114 static struct sti_blkmv_flags clear_blkmv_flags = {
 115         STI_WAIT, 1, 1, 0, 0, NULL
 116 };
 117
 118 void
 119 sti_set(struct sti_struct *sti, int src_y, int src_x,
 120         int height, int width, u8 color)
 121 {
 122         struct sti_blkmv_inptr inptr = {
 123                 color, color,
 124                 src_x, src_y ,
 125                 src_x, src_y ,
 126                 width, height,
 127                 NULL
 128         };
 129         struct sti_blkmv_outptr outptr = { 0, NULL };
 130         s32 ret = 0;
 131         unsigned long flags;
 132
 133         do {
 134                 spin_lock_irqsave(&sti->lock, flags);
 135                 ret = STI_CALL(sti->block_move, &clear_blkmv_flags,
 136                         &inptr, &outptr, sti->glob_cfg);
 137                 spin_unlock_irqrestore(&sti->lock, flags);
 138         } while(ret == 1);
 139 }
 140
 141 void
 142 sti_clear(struct sti_struct *sti, int src_y, int src_x,
 143           int height, int width)
 144 {
 145         struct sti_blkmv_inptr inptr = {
 146                 0, 0,
 147                 src_x * sti_font_x(sti), src_y * sti_font_y(sti),
 148                 src_x * sti_font_x(sti), src_y * sti_font_y(sti),
 149                 width * sti_font_x(sti), height* sti_font_y(sti),
 150                 NULL
 151         };
 152         struct sti_blkmv_outptr outptr = { 0, NULL };
 153         s32 ret = 0;
 154         unsigned long flags;
 155
 156         do {
 157                 spin_lock_irqsave(&sti->lock, flags);
 158                 ret = STI_CALL(sti->block_move, &clear_blkmv_flags,
 159                         &inptr, &outptr, sti->glob_cfg);
 160                 spin_unlock_irqrestore(&sti->lock, flags);
 161         } while(ret == 1);
 162 }
 163
 164 static struct sti_blkmv_flags default_blkmv_flags = {
 165         STI_WAIT, 0, 0, 0, 0, NULL
 166 };
 167
 168 void
 169 sti_bmove(struct sti_struct *sti, int src_y, int src_x,
 170           int dst_y, int dst_x, int height, int width)
 171 {
 172         struct sti_blkmv_inptr inptr = {
 173                 0, 0,
 174                 src_x * sti_font_x(sti), src_y * sti_font_y(sti),
 175                 dst_x * sti_font_x(sti), dst_y * sti_font_y(sti),
 176                 width * sti_font_x(sti), height* sti_font_y(sti),
 177                 NULL
 178         };
 179         struct sti_blkmv_outptr outptr = { 0, NULL };
 180         s32 ret = 0;
 181         unsigned long flags;
 182
 183         do {
 184                 spin_lock_irqsave(&sti->lock, flags);
 185                 ret = STI_CALL(sti->block_move, &default_blkmv_flags,
 186                         &inptr, &outptr, sti->glob_cfg);
 187                 spin_unlock_irqrestore(&sti->lock, flags);
 188         } while(ret == 1);
 189 }
 190
 191
 192 static void __init
 193 sti_rom_copy(unsigned long base, unsigned long offset,
 194              unsigned long count, void *dest)
 195 {
 196         void *savedest = dest;
 197         int savecount = count;
 198
 199         while(count >= 4) {
 200                 count -= 4;
 201                 *(u32 *)dest = gsc_readl(base + offset);
 202                 offset += 4;
 203                 dest += 4;
 204         }
 205         while(count) {
 206                 count--;
 207                 *(u8 *)dest = gsc_readb(base + offset);
 208                 offset++;
 209                 dest++;
 210         }
 211         __flush_dcache_range((unsigned long) dest, count);
 212         __flush_icache_range((unsigned long) dest, count);
 213 }
 214
 215 static void dump_sti_rom(struct sti_rom *rom)
 216 {
 217         printk("STI word mode ROM type %d\n", rom->type[3]);
 218         printk(" supports %d monitors\n", rom->num_mons);
 219         printk(" conforms to STI ROM spec revision %d.%02x\n",
 220                 rom->revno[0] >> 4, rom->revno[0] & 0x0f);
 221         printk(" graphics id %02x%02x%02x%02x%02x%02x%02x%02x\n",
 222                 rom->graphics_id[0],
 223                 rom->graphics_id[1],
 224                 rom->graphics_id[2],
 225                 rom->graphics_id[3],
 226                 rom->graphics_id[4],
 227                 rom->graphics_id[5],
 228                 rom->graphics_id[6],
 229                 rom->graphics_id[7]);
 230         printk(" font start %08x\n", rom->font_start);
 231         printk(" region list %08x\n", rom->region_list);
 232         printk(" init_graph %08x\n", rom->init_graph);
 233         printk(" alternate code type %d\n", rom->alt_code_type);
 234 }
 235
 236 static void __init sti_cook_fonts(struct sti_cooked_rom *cooked_rom,
 237                                   struct sti_rom *raw_rom)
 238 {
 239         struct sti_rom_font *raw_font;
 240         struct sti_cooked_font *cooked_font;
 241         struct sti_rom_font *font_start;
 242
 243         cooked_font =
 244                 kmalloc(sizeof *cooked_font, GFP_KERNEL);
 245         if(!cooked_font)
 246                 return;
 247
 248         cooked_rom->font_start = cooked_font;
 249
 250         raw_font = ((void *)raw_rom) + (raw_rom->font_start);
 251
 252         font_start = raw_font;
 253         cooked_font->raw = raw_font;
 254
 255         while(raw_font->next_font) {
 256                 raw_font = ((void *)font_start) + (raw_font->next_font);
 257
 258                 cooked_font->next_font =
 259                         kmalloc(sizeof *cooked_font, GFP_KERNEL);
 260                 if(!cooked_font->next_font)
 261                         return;
 262
 263                 cooked_font = cooked_font->next_font;
 264
 265                 cooked_font->raw = raw_font;
 266         }
 267
 268         cooked_font->next_font = NULL;
 269 }
 270
 271 static int font_index, font_height, font_width;
 272
 273 static int __init sti_font_setup(char *str)
 274 {
 275         char *x;
 276
 277         /* we accept sti_font=10x20, sti_font=10*20 or sti_font=7 style
 278          * command lines. */
 279
 280         if((x = strchr(str, 'x')) || (x = strchr(str, '*'))) {
 281                 font_height = simple_strtoul(str, NULL, 0);
 282                 font_width = simple_strtoul(x+1, NULL, 0);
 283         } else {
 284                 font_index = simple_strtoul(str, NULL, 0);
 285         }
 286
 287         return 0;
 288 }
 289
 290 __setup("sti_font=", sti_font_setup);
 291
 292 static int __init sti_search_font(struct sti_cooked_rom *rom,
 293                                   int height, int width)
 294 {
 295         struct sti_cooked_font *font;
 296         int i = 0;
 297
 298         for(font = rom->font_start; font; font = font->next_font, i++) {
 299                 if((font->raw->width == width) && (font->raw->height == height))
 300                         return i;
 301         }
 302
 303         return 0;
 304 }
 305
 306 static struct sti_cooked_font * __init
 307 sti_select_font(struct sti_cooked_rom *rom)
 308 {
 309         struct sti_cooked_font *font;
 310         int i;
 311
 312         if(font_width && font_height)
 313                 font_index = sti_search_font(rom, font_height, font_width);
 314
 315         for(font = rom->font_start, i = font_index;
 316             font && (i > 0);
 317             font = font->next_font, i--);
 318
 319         if(font)
 320                 return font;
 321         else
 322                 return rom->font_start;
 323 }
 324
 325 static void __init
 326 sti_dump_globcfg_ext(struct sti_glob_cfg_ext *cfg)
 327 {
 328         printk( "monitor %d\n"
 329                 "in friendly mode: %d\n"
 330                 "power consumption %d watts\n"
 331                 "freq ref %d\n"
 332                 "sti_mem_addr %p\n",
 333                 cfg->curr_mon,
 334                 cfg->friendly_boot,
 335                 cfg->power,
 336                 cfg->freq_ref,
 337                 cfg->sti_mem_addr);
 338 }
 339
 340 void __init
 341 sti_dump_globcfg(struct sti_glob_cfg *glob_cfg)
 342 {
 343         printk( "%d text planes\n"
 344                 "%4d x %4d screen resolution\n"
 345                 "%4d x %4d offscreen\n"
 346                 "%4d x %4d layout\n"
 347                 "regions at %08x %08x %08x %08x\n"
 348                 "regions at %08x %08x %08x %08x\n"
 349                 "reent_lvl %d\n"
 350                 "save_addr %p\n",
 351                 glob_cfg->text_planes,
 352                 glob_cfg->onscreen_x, glob_cfg->onscreen_y,
 353                 glob_cfg->offscreen_x, glob_cfg->offscreen_y,
 354                 glob_cfg->total_x, glob_cfg->total_y,
 355                 glob_cfg->region_ptrs[0], glob_cfg->region_ptrs[1],
 356                 glob_cfg->region_ptrs[2], glob_cfg->region_ptrs[3],
 357                 glob_cfg->region_ptrs[4], glob_cfg->region_ptrs[5],
 358                 glob_cfg->region_ptrs[6], glob_cfg->region_ptrs[7],
 359                 glob_cfg->reent_lvl,
 360                 glob_cfg->save_addr);
 361         sti_dump_globcfg_ext(PTR_STI(glob_cfg->ext_ptr));
 362 }
 363
 364 static void __init
 365 sti_init_glob_cfg(struct sti_struct *sti, unsigned long hpa,
 366                   unsigned long rom_address)
 367 {
 368         struct sti_glob_cfg *glob_cfg;
 369         struct sti_glob_cfg_ext *glob_cfg_ext;
 370         void *save_addr;
 371         void *sti_mem_addr;
 372
 373         glob_cfg = kmalloc(sizeof *sti->glob_cfg, GFP_KERNEL);
 374         glob_cfg_ext = kmalloc(sizeof *glob_cfg_ext, GFP_KERNEL);
 375         save_addr = kmalloc(1024 /*XXX*/, GFP_KERNEL);
 376         sti_mem_addr = kmalloc(1024, GFP_KERNEL);
 377
 378         if((!glob_cfg) || (!glob_cfg_ext) || (!save_addr) || (!sti_mem_addr))
 379                 return;
 380
 381         memset(glob_cfg, 0, sizeof *glob_cfg);
 382         memset(glob_cfg_ext, 0, sizeof *glob_cfg_ext);
 383         memset(save_addr, 0, 1024);
 384         memset(sti_mem_addr, 0, 1024);
 385
 386         glob_cfg->ext_ptr = STI_PTR(glob_cfg_ext);
 387         glob_cfg->save_addr = STI_PTR(save_addr);
 388         glob_cfg->region_ptrs[0] = ((sti->regions[0]>>18)<<12) + rom_address;
 389         glob_cfg->region_ptrs[1] = ((sti->regions[1]>>18)<<12) + hpa;
 390         glob_cfg->region_ptrs[2] = ((sti->regions[2]>>18)<<12) + hpa;
 391         glob_cfg->region_ptrs[3] = ((sti->regions[3]>>18)<<12) + hpa;
 392         glob_cfg->region_ptrs[4] = ((sti->regions[4]>>18)<<12) + hpa;
 393         glob_cfg->region_ptrs[5] = ((sti->regions[5]>>18)<<12) + hpa;
 394         glob_cfg->region_ptrs[6] = ((sti->regions[6]>>18)<<12) + hpa;
 395         glob_cfg->region_ptrs[7] = ((sti->regions[7]>>18)<<12) + hpa;
 396
 397         glob_cfg_ext->sti_mem_addr = STI_PTR(sti_mem_addr);
 398
 399         sti->glob_cfg = STI_PTR(glob_cfg);
 400 }
 401
 402 /* address is a pointer to a word mode or pci rom */
 403 static struct sti_struct * __init
 404 sti_read_rom(unsigned long address)
 405 {
 406         struct sti_struct *ret = NULL;
 407         struct sti_cooked_rom *cooked = NULL;
 408         struct sti_rom *raw = NULL;
 409         unsigned long size;
 410
 411         ret = &default_sti;
 412
 413         if(!ret)
 414                 goto out_err;
 415
 416         cooked = kmalloc(sizeof *cooked, GFP_KERNEL);
 417         raw = kmalloc(sizeof *raw, GFP_KERNEL);
 418
 419         if(!(raw && cooked))
 420                 goto out_err;
 421
 422         /* reallocate raw */
 423         sti_rom_copy(address, 0, sizeof *raw, raw);
 424
 425         dump_sti_rom(raw);
 426
 427         size = raw->last_addr;
 428         /* kfree(raw); */
 429         raw = kmalloc(size, GFP_KERNEL);
 430         if(!raw)
 431                 goto out_err;
 432         sti_rom_copy(address, 0, size, raw);
 433
 434         sti_cook_fonts(cooked, raw);
 435 #if 0
 436         sti_cook_regions(cooked, raw);
 437         sti_cook_functions(cooked, raw);
 438 #endif
 439
 440         if(raw->region_list) {
 441                 ret->regions = kmalloc(32, GFP_KERNEL); /* FIXME */
 442
 443                 memcpy(ret->regions, ((void *)raw)+raw->region_list, 32);
 444         }
 445
 446         address = virt_to_phys(raw);
 447
 448         ret->font_unpmv = address+(raw->font_unpmv & 0x03ffffff);
 449         ret->block_move = address+(raw->block_move & 0x03ffffff);
 450         ret->init_graph = address+(raw->init_graph & 0x03ffffff);
 451         ret->inq_conf = address+(raw->inq_conf     & 0x03ffffff);
 452
 453         ret->rom = cooked;
 454         ret->rom->raw = raw;
 455
 456         ret->font = (struct sti_rom_font *) virt_to_phys(sti_select_font(ret->rom)->raw);
 457
 458         return ret;
 459
 460 out_err:
 461         if(raw)
 462                 kfree(raw);
 463         if(cooked)
 464                 kfree(cooked);
 465
 466         return NULL;
 467 }
 468
 469 static struct sti_struct * __init
 470 sti_try_rom(unsigned long address, unsigned long hpa)
 471 {
 472         struct sti_struct *sti = NULL;
 473         u16 sig;
 474
 475 test_rom:
 476         /* if we can't read the ROM, bail out early.  Not being able
 477          * to read the hpa is okay, for romless sti */
 478         if(pdc_add_valid((void*)address))
 479                 return NULL;
 480
 481         printk("found potential STI ROM at %08lx\n", address);
 482
 483         sig = le16_to_cpu(gsc_readw(address));
 484
 485         if((sig==0x55aa) || (sig==0xaa55)) {
 486                 address += le32_to_cpu(gsc_readl(address+8));
 487                 printk("sig %04x, PCI STI ROM at %08lx\n",
 488                        sig, address);
 489
 490                 goto test_rom;
 491         }
 492
 493         if((sig&0xff) == 0x01) {
 494                 printk("STI byte mode ROM at %08lx, ignored\n",
 495                        address);
 496
 497                 sti = NULL;
 498         }
 499
 500         if(sig == 0x0303) {
 501                 printk("STI word mode ROM at %08lx\n",
 502                        address);
 503
 504                 sti = sti_read_rom(address);
 505         }
 506
 507         if (!sti)
 508                 return NULL;
 509
 510         /* this is hacked.  We need a better way to find out the HPA for
 511          * romless STI (eg search for the graphics devices we know about
 512          * by sversion) */
 513         if (!pdc_add_valid((void *)0xf5000000)) printk("f4000000 g\n");
 514         if (!pdc_add_valid((void *)0xf7000000)) printk("f6000000 g\n");
 515         if (!pdc_add_valid((void *)0xf9000000)) printk("f8000000 g\n");
 516         if (!pdc_add_valid((void *)0xfb000000)) printk("fa000000 g\n");
 517         sti_init_glob_cfg(sti, hpa, address);
 518
 519         sti_init_graph(sti);
 520
 521         sti_inq_conf(sti);
 522         sti_dump_globcfg(PTR_STI(sti->glob_cfg));
 523
 524         return sti;
 525 }
 526
 527 static unsigned long sti_address;
 528 static unsigned long sti_hpa;
 529
 530 /* XXX: should build a list of STI ROMs */
 531 struct sti_struct * __init
 532 sti_init_roms(void)
 533 {
 534         struct sti_struct *tmp = NULL, *sti = NULL;
 535
 536         /* handle the command line */
 537         if (sti_address && sti_hpa) {
 538                 return sti_try_rom(sti_address, sti_hpa);
 539         }
 540
 541         /* 712, 715, some other boxes don't have a separate STI ROM,
 542          * but use part of the regular flash */
 543         if (PAGE0->proc_sti) {
 544                 printk("STI ROM from PDC at %08x\n", PAGE0->proc_sti);
 545                 if (!pdc_add_valid((void *)0xf9000000))
 546                         sti = sti_try_rom(PAGE0->proc_sti, 0xf8000000);
 547                 else if (!pdc_add_valid((void *)0xf5000000))
 548                         sti = sti_try_rom(PAGE0->proc_sti, 0xf4000000);
 549                 else if (!pdc_add_valid((void *)0xf7000000))
 550                         sti = sti_try_rom(PAGE0->proc_sti, 0xf6000000);
 551                 else if (!pdc_add_valid((void *)0xfb000000))
 552                         sti = sti_try_rom(PAGE0->proc_sti, 0xfa000000);
 553
 554         }
 555
 556         /* standard locations for GSC graphic devices */
 557         if (!pdc_add_valid((void *)0xf4000000))
 558                 tmp = sti_try_rom(0xf4000000, 0xf4000000);
 559         sti = tmp ? tmp : sti;
 560         if (!pdc_add_valid((void *)0xf6000000))
 561                 tmp = sti_try_rom(0xf6000000, 0xf6000000);
 562         sti = tmp ? tmp : sti;
 563         if (!pdc_add_valid((void *)0xf8000000))
 564                 tmp = sti_try_rom(0xf8000000, 0xf8000000);
 565         sti = tmp ? tmp : sti;
 566         if (!pdc_add_valid((void *)0xfa000000))
 567                 tmp = sti_try_rom(0xfa000000, 0xfa000000);
 568         sti = tmp ? tmp : sti;
 569
 570         return sti;
 571 }
 572
 573 static int __init
 574 sti_setup(char *str)
 575 {
 576         char *end;
 577
 578         if(strcmp(str, "pdc") == 0) {
 579                 sti_address = PAGE0->proc_sti;
 580
 581                 return 1;
 582         } else {
 583                 sti_address = simple_strtoul(str, &end, 16);
 584
 585                 if((end == str) || (sti_address < 0xf0000000)) {
 586                         sti_address = 0;
 587                         return 0;
 588                 }
 589
 590                 sti_hpa = sti_address;
 591
 592                 return 1;
 593         }
 594
 595         return 0;
 596 }
 597
 598 __setup("sti=", sti_setup);