[apple/bootx.git] / bootx.tproj / sl.subproj / display.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *  display.c - Functions to manage and find display.
 *
 *  Copyright (c) 1998-2002 Apple Computer, Inc.
 *
 *  DRI: Josh de Cesare
 */

#include <sl.h>

#include "clut.h"
#include "appleboot.h"
#include "failedboot.h"
#include "netboot.h"

struct DisplayInfo {
  CICell screenPH;
  CICell screenIH;
  CICell address;
  CICell width;
  CICell height;
  CICell depth;
  CICell linebytes;
  CICell triedToOpen;
};

typedef struct DisplayInfo DisplayInfo, *DisplayInfoPtr;


static long FindDisplays(void);
static long OpenDisplays(void);
static long OpenDisplay(long displayNum);
static long InitDisplay(long displayNum);
static long LookUpCLUTIndex(long index, long depth);

static long        gNumDisplays;
static long        gMainDisplayNum;
static DisplayInfo gDisplays[16];

static unsigned char *gAppleBoot;
static unsigned char *gNetBoot;
static unsigned char *gFailedBoot;

// Public Functions

long InitDisplays(void)
{
  FindDisplays();
  OpenDisplays();
  
  return 0;
}


long DrawSplashScreen(long stage)
{
  DisplayInfoPtr display;
  short          *appleBoot16, *netBoot16;
  long           *appleBoot32, *netBoot32;
  long           cnt, x, y, pixelSize;
  
  if (gMainDisplayNum == -1) return 0;
  
  display = &gDisplays[gMainDisplayNum];
  
  switch (stage) {
  case 0 :
    // Make sure the boot display is marked.
    SetProp(display->screenPH, "AAPL,boot-display", NULL, 0);
    
    switch (display->depth) {
    case 16 :
      appleBoot16 =
	AllocateBootXMemory(kAppleBootWidth * kAppleBootHeight * 2);
      for (cnt = 0; cnt < (kAppleBootWidth * kAppleBootHeight); cnt++)
	appleBoot16[cnt] = LookUpCLUTIndex(gAppleBootPict[cnt], 16);
      gAppleBoot = (char *)appleBoot16;
      break;
      
    case 32 :
      appleBoot32 =
	AllocateBootXMemory(kAppleBootWidth * kAppleBootHeight * 4);
      for (cnt = 0; cnt < (kAppleBootWidth * kAppleBootHeight); cnt++)
	appleBoot32[cnt] = LookUpCLUTIndex(gAppleBootPict[cnt], 32);
      gAppleBoot = (char *)appleBoot32;
      break;
      
    default :
      gAppleBoot = (unsigned char *)gAppleBootPict;
      break;
    }
    
    x = (display->width - kAppleBootWidth) / 2;
    y = (display->height - kAppleBootHeight) / 2 + kAppleBootOffset;
    
    CallMethod(5, 0, display->screenIH, "draw-rectangle", (long)gAppleBoot,
	       x, y, kAppleBootWidth, kAppleBootHeight);
    
    if (gBootFileType != kNetworkDeviceType) {
      SpinInit(0, 0, NULL, 0, 0, 0, 0, 0, 0, 0);
    } else {
      switch (display->depth) {
      case 16 :
	pixelSize = 2;
	netBoot16 =
	  AllocateBootXMemory(kNetBootWidth * kNetBootHeight * kNetBootFrames * 2);
	for (cnt = 0; cnt < (kNetBootWidth * kNetBootHeight * kNetBootFrames); cnt++)
	  netBoot16[cnt] = LookUpCLUTIndex(gNetBootPict[cnt], 16);
	gNetBoot = (char *)netBoot16;
	break;
	
      case 32 :
	pixelSize = 4;
	netBoot32 =
	  AllocateBootXMemory(kNetBootWidth * kNetBootHeight * kNetBootFrames * 4);
	for (cnt = 0; cnt < (kNetBootWidth * kNetBootHeight * kNetBootFrames); cnt++)
	  netBoot32[cnt] = LookUpCLUTIndex(gNetBootPict[cnt], 32);
	gNetBoot = (char *)netBoot32;
	break;
	
      default :
	pixelSize = 1;
	gNetBoot = (unsigned char *)gNetBootPict;
	break;
      }
      
      x = (display->width - kNetBootWidth) / 2;
      y = (display->height - kNetBootHeight) / 2 + kNetBootOffset;
      
      CallMethod(5, 0, display->screenIH, "draw-rectangle", (long)gNetBoot,
		 x, y, kNetBootWidth, kNetBootHeight);
      
      // Set up the spin cursor.
      SpinInit(display->screenIH, gNetBoot,
	       x, y,
	       kNetBootWidth, kNetBootHeight,
	       kNetBootFrames, kNetBootFPS, pixelSize, 0);
    }
    break;
    
  case 1 :
    x = (display->width - kAppleBootWidth) / 2;
    y = (display->height - kAppleBootHeight) / 2 + kAppleBootOffset;
    
    CallMethod(5, 0, display->screenIH, "draw-rectangle", (long)gAppleBoot,
	       x, y, kAppleBootWidth, kAppleBootHeight);
    
    if (gBootFileType == kNetworkDeviceType) {
      x = (display->width - kNetBootWidth) / 2;
      y = (display->height - kNetBootHeight) / 2 + kNetBootOffset;
      
      // Erase the netboot picture with 75% grey.
      CallMethod(5, 0, display->screenIH, "fill-rectangle",
		 LookUpCLUTIndex(0x01, display->depth),
		 x, y, kNetBootWidth, kNetBootHeight);
    }
    break;
    
  default :
    return -1;
    break;
  }
  
  return 0;
}


long DrawFailedBootPicture(void)
{
  long           cnt;
  short          *failedBoot16;
  long           *failedBoot32, posX, posY;
  DisplayInfoPtr display = &gDisplays[gMainDisplayNum];
  
  switch (display->depth) {
  case 16 :
    failedBoot16 = AllocateBootXMemory(32 * 32 * 2);
    for (cnt = 0; cnt < (32 * 32); cnt++)
      failedBoot16[cnt] = LookUpCLUTIndex(gFailedBootPict[cnt], 16);
    gFailedBoot = (char *)failedBoot16;
    break;
    
  case 32 :
    failedBoot32 = AllocateBootXMemory(32 * 32 * 4);
    for (cnt = 0; cnt < (32 * 32); cnt++)
      failedBoot32[cnt] = LookUpCLUTIndex(gFailedBootPict[cnt], 32);
    gFailedBoot = (char *)failedBoot32;
    break;
    
  default :
    gFailedBoot = (unsigned char *)gFailedBootPict;
    break;
  }
  
  // Erase the newboot picture with 75% grey.
  posX = (display->width - kNetBootWidth) / 2;
  posY = (display->height - kNetBootHeight) / 2 + kNetBootOffset;
  CallMethod(5, 0, display->screenIH, "fill-rectangle",
	     LookUpCLUTIndex(0x01, display->depth),
	     posX, posY, kNetBootWidth, kNetBootHeight);
  
  // Draw the failed boot picture.
  posX = (display->width - kFailedBootWidth) / 2;
  posY = ((display->height - kFailedBootHeight)) / 2 + kFailedBootOffset;
  CallMethod(5, 0, display->screenIH, "draw-rectangle",
	     (long)gFailedBoot, posX, posY,
	     kFailedBootWidth, kFailedBootHeight);
  
  return 0;
}


void GetMainScreenPH(Boot_Video_Ptr video)
{
  DisplayInfoPtr display;
  long           address, size;
  
  if (gMainDisplayNum == -1) {
    // No display, set it to zero.
    video->v_baseAddr = 0;
    video->v_rowBytes = 0;
    video->v_width = 0;
    video->v_height = 0;
    video->v_depth = 0;
  } else {
    display = &gDisplays[gMainDisplayNum];
    
    video->v_baseAddr = display->address;
    video->v_rowBytes = display->linebytes;
    video->v_width = display->width;
    video->v_height = display->height;
    video->v_depth = display->depth;
  }
  
  // Allocate memory and a range for the CLUT.
  size = 256 * 3;
  address = AllocateKernelMemory(size);
  AllocateMemoryRange("BootCLUT", address, size);
  bcopy((char *)gClut, (char *)address, size);
  
  // Allocate memory and a range for the failed boot picture.
  size = 32 + kFailedBootWidth * kFailedBootHeight;
  address = AllocateKernelMemory(size);
  AllocateMemoryRange("Pict-FailedBoot", address, size);
  ((long *)address)[0] = kFailedBootWidth;
  ((long *)address)[1] = kFailedBootHeight;
  ((long *)address)[2] = kFailedBootOffset;
  bcopy((char *)gFailedBootPict, (char *)(address + 32), size - 32);
}


// Private Functions

static long FindDisplays(void)
{
  CICell screenPH, controlPH;
  long   cnt;
  
  // Find all the screens in the system.
  screenPH = 0;
  while (1) {
    screenPH = SearchForNode(screenPH, 1, "device_type", "display");
    if (screenPH != 0) gDisplays[gNumDisplays++].screenPH = screenPH;
    else break;
  }
  
  // Find /chaos/control, and
  // invalidate gStdOutPH if equal (since new OF was downloaded).
  controlPH = FindDevice("/chaos/control");
  if (gStdOutPH == controlPH) gStdOutPH = 0;
  
  // Find the main screen using the screen alias or chaos/control.
  gMainDisplayNum = -1;
  screenPH = FindDevice("screen");
  if (screenPH == -1) screenPH = controlPH;
  for (cnt = 0; cnt < gNumDisplays; cnt++)
    if (gDisplays[cnt].screenPH == screenPH) gMainDisplayNum = cnt;
  
  return 0;
}


static long OpenDisplays(void)
{
  long cnt;
  
  // Open the main screen or
  // look for a main screen if we don't have one.
  if ((gMainDisplayNum == -1) || !OpenDisplay(gMainDisplayNum)) {
    gMainDisplayNum = -1;
    for (cnt = 0; cnt < gNumDisplays; cnt++) {
      if (OpenDisplay(cnt)) {
	gMainDisplayNum = cnt;
	break;
      }
    }
  }
  
  // Open the rest of the displays
  if (gOFVersion >= kOFVersion3x) {
    for (cnt = 0; cnt < gNumDisplays; cnt++) {
      OpenDisplay(cnt);
    }
  }
  
  return 0;
}


static long OpenDisplay(long displayNum)
{
  char   screenPath[258], displayType[32];
  CICell screenPH, screenIH;
  long   ret, size;
  
  // Only try to open a screen once.
  if (gDisplays[displayNum].triedToOpen) {
    return gDisplays[displayNum].screenIH != 0;
  } else {
    gDisplays[displayNum].triedToOpen = -1;
  }
  
  screenPH = gDisplays[displayNum].screenPH;
  
  // Try to use mac-boot's ihandle.
  Interpret(0, 1, "\" _screen-ihandle\" $find if execute else 0 then",
	    &screenIH);
  if ((screenIH != 0) && (InstanceToPackage(screenIH) != screenPH)) {
    screenIH = 0;
  }
  
  // Try to use stdout as the screen's ihandle
  if ((screenIH == 0) && (gStdOutPH == screenPH)) {
    screenIH = gStdOutIH;
  }
  
  // Try to open the display.
  if (screenIH == 0) {
    screenPath[255] = '\0';
    ret = PackageToPath(screenPH, screenPath, 255);
    if (ret != -1) {
      strcat(screenPath, ":0");
      screenIH = Open(screenPath);
    }
  }
  
  // Find out what type of display is attached.
  size = GetProp(screenPH, "display-type", displayType, 31);
  if (size != -1) {
    displayType[size] = '\0';
    // If the display-type is NONE, don't use the display.
    if (!strcmp(displayType, "NONE")) screenIH = 0;
  }
  
  // Save the ihandle for later use.
  gDisplays[displayNum].screenIH = screenIH;
  
  // Initialize the display.
  if (screenIH != 0) InitDisplay(displayNum);
  
  return screenIH != 0;
}


static long InitDisplay(long displayNum)
{
  DisplayInfoPtr display = &gDisplays[displayNum];
  CICell         screenPH = display->screenPH;
  CICell         screenIH = display->screenIH;
  
  // Get the vital info for this screen.
  GetProp(screenPH, "address", (char *)&(display->address), 4);
  GetProp(screenPH, "width", (char *)&(display->width), 4);
  GetProp(screenPH, "height", (char *)&(display->height), 4);
  GetProp(screenPH, "depth", (char *)&(display->depth), 4);
  GetProp(screenPH, "linebytes", (char *)&(display->linebytes), 4);
  
  // Replace some of the drivers words.
  Interpret(3, 1,
   " value depthbytes"
   " value rowbytes"
   " to active-package"
   " frame-buffer-adr value this-frame-buffer-adr"
   
   " : rect-setup"      // ( adr|index x y w h -- w adr|index xy-adr h )
   "   >r >r rowbytes * swap depthbytes * + this-frame-buffer-adr +"
   "   r> depthbytes * -rot r>"
   " ;"
   
   " : DRAW-RECTANGLE"                          // ( adr x y w h -- )
   "   rect-setup"                              // ( w adr xy-adr h )
   "   0 ?do"                                   // ( w adr xy-adr )
   "     2dup 4 pick move"
   "     2 pick rowbytes d+"
   "   loop"
   "   3drop"
   " ;"
   
   " : FILL-RECTANGLE"                           // ( index x y w h -- )
   "   rect-setup rot depthbytes case"
   "     1 of dup 8 << or dup 10 << or endof"
   "     2 of dup 10 << or endof"
   "   endcase -rot 0 ?do"
   "     dup 3 pick 3 pick filll"
   "     rowbytes +"
   "   loop"
   "   3drop"
   " ;"
   
   " : READ-RECTANGLE"                            // ( adr x y w h -- )
   "   rect-setup  >r swap r> 0 ?do"
   "     2dup 4 pick move"
   "     rowbytes 3 pick d+"
   "   loop"
   "   3drop"
   " ;"
   
   " this-frame-buffer-adr"
   " 0 to active-package"
   , display->screenPH, display->linebytes,
   display->depth / 8, &display->address);
  
  // Set the CLUT for 8 bit displays.
  if (display->depth == 8) {
    CallMethod(3, 0, screenIH, "set-colors", (long)gClut, 0, 256);
  }
  
  // Set the screen to 75% grey.
  CallMethod(5, 0, screenIH, "fill-rectangle",
	     LookUpCLUTIndex(0x01, display->depth),
	     0, 0, display->width, display->height);
  
  return 0;
}


static long LookUpCLUTIndex(long index, long depth)
{
  long result, red, green, blue;
  
  red   = gClut[index * 3 + 0];
  green = gClut[index * 3 + 1];
  blue  = gClut[index * 3 + 2];
  
  switch (depth) {
  case 16 :
    result = ((red & 0xF8) << 7)|((green & 0xF8) << 2)|((blue & 0xF8) >> 3);
    break;
    
  case 32 :
    result = (red << 16) | (green << 8) | blue;
    break;
    
  default :
    result = index;
    break;
  }
  
  return result;
}


#if 0
static void DumpDisplaysInfo(void);

static void DumpDisplaysInfo(void)
{
  long cnt, length;
  char tmpStr[512];
  
  printf("gNumDisplays: %x, gMainDisplayNum: %x\n",
	 gNumDisplays, gMainDisplayNum);
  
  for (cnt = 0; cnt < gNumDisplays; cnt++) {
    printf("Display: %x, screenPH: %x,  screenIH: %x\n",
	   cnt, gDisplays[cnt].screenPH, gDisplays[cnt].screenIH);
    
    if (gDisplays[cnt].screenPH) {
      length = PackageToPath(gDisplays[cnt].screenPH, tmpStr, 511);
      tmpStr[length] = '\0';
      printf("PHandle Path: %s\n", tmpStr);
    }
    
    if (gDisplays[cnt].screenIH) {
      length = InstanceToPath(gDisplays[cnt].screenIH, tmpStr, 511);
      tmpStr[length] = '\0';
      printf("IHandle Path: %s\n", tmpStr);
    }
    
    printf("address = %x\n", gDisplays[cnt].address);
    printf("linebytes = %x\n", gDisplays[cnt].linebytes);
    printf("width = %x\n", gDisplays[cnt].width);
    printf("height = %x\n", gDisplays[cnt].height);
    printf("depth = %x\n", gDisplays[cnt].depth);
    printf("\n");
  }
}
#endif
Commit	Line	Data
04fee52e A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
db839b1d	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
04fee52e	7	*
db839b1d A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
04fee52e A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
04fee52e A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
db839b1d A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
04fee52e A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
366defd1	26	* display.c - Functions to manage and find display.
04fee52e	27	*
366defd1	28	* Copyright (c) 1998-2002 Apple Computer, Inc.
04fee52e A	29	*
	30	* DRI: Josh de Cesare
	31	*/
	32
	33	#include <sl.h>
	34
	35	#include "clut.h"
366defd1 A	36	#include "appleboot.h"
	37	#include "failedboot.h"
	38	#include "netboot.h"
04fee52e A	39
	40	struct DisplayInfo {
	41	CICell screenPH;
	42	CICell screenIH;
	43	CICell address;
	44	CICell width;
	45	CICell height;
	46	CICell depth;
	47	CICell linebytes;
853f9ac3	48	CICell triedToOpen;
04fee52e A	49	};
	50
	51	typedef struct DisplayInfo DisplayInfo, *DisplayInfoPtr;
	52
04fee52e A	53
	54	static long FindDisplays(void);
	55	static long OpenDisplays(void);
04fee52e A	56	static long OpenDisplay(long displayNum);
04fee52e A	57	static long InitDisplay(long displayNum);
04fee52e A	58	static long LookUpCLUTIndex(long index, long depth);
	59
	60	static long gNumDisplays;
	61	static long gMainDisplayNum;
	62	static DisplayInfo gDisplays[16];
	63
366defd1 A	64	static unsigned char *gAppleBoot;
	65	static unsigned char *gNetBoot;
	66	static unsigned char *gFailedBoot;
	67
04fee52e A	68	// Public Functions
	69
	70	long InitDisplays(void)
	71	{
	72	FindDisplays();
	73	OpenDisplays();
	74
	75	return 0;
	76	}
	77
	78
366defd1	79	long DrawSplashScreen(long stage)
04fee52e A	80	{
04fee52e A	81	DisplayInfoPtr display;
366defd1 A	82	short appleBoot16, netBoot16;
366defd1 A	83	long appleBoot32, netBoot32;
04fee52e A	84	long cnt, x, y, pixelSize;
	85
	86	if (gMainDisplayNum == -1) return 0;
	87
	88	display = &gDisplays[gMainDisplayNum];
	89
366defd1 A	90	switch (stage) {
	91	case 0 :
	92	// Make sure the boot display is marked.
	93	SetProp(display->screenPH, "AAPL,boot-display", NULL, 0);
04fee52e A	94
	95	switch (display->depth) {
	96	case 16 :
366defd1 A	97	appleBoot16 =
	98	AllocateBootXMemory(kAppleBootWidth * kAppleBootHeight * 2);
	99	for (cnt = 0; cnt < (kAppleBootWidth * kAppleBootHeight); cnt++)
	100	appleBoot16[cnt] = LookUpCLUTIndex(gAppleBootPict[cnt], 16);
	101	gAppleBoot = (char *)appleBoot16;
04fee52e A	102	break;
	103
	104	case 32 :
366defd1 A	105	appleBoot32 =
	106	AllocateBootXMemory(kAppleBootWidth * kAppleBootHeight * 4);
	107	for (cnt = 0; cnt < (kAppleBootWidth * kAppleBootHeight); cnt++)
	108	appleBoot32[cnt] = LookUpCLUTIndex(gAppleBootPict[cnt], 32);
	109	gAppleBoot = (char *)appleBoot32;
04fee52e A	110	break;
	111
	112	default :
366defd1	113	gAppleBoot = (unsigned char *)gAppleBootPict;
04fee52e A	114	break;
	115	}
	116
366defd1 A	117	x = (display->width - kAppleBootWidth) / 2;
	118	y = (display->height - kAppleBootHeight) / 2 + kAppleBootOffset;
	119
	120	CallMethod(5, 0, display->screenIH, "draw-rectangle", (long)gAppleBoot,
	121	x, y, kAppleBootWidth, kAppleBootHeight);
	122
	123	if (gBootFileType != kNetworkDeviceType) {
	124	SpinInit(0, 0, NULL, 0, 0, 0, 0, 0, 0, 0);
	125	} else {
	126	switch (display->depth) {
	127	case 16 :
	128	pixelSize = 2;
	129	netBoot16 =
	130	AllocateBootXMemory(kNetBootWidth * kNetBootHeight * kNetBootFrames * 2);
	131	for (cnt = 0; cnt < (kNetBootWidth * kNetBootHeight * kNetBootFrames); cnt++)
	132	netBoot16[cnt] = LookUpCLUTIndex(gNetBootPict[cnt], 16);
	133	gNetBoot = (char *)netBoot16;
	134	break;
	135
	136	case 32 :
	137	pixelSize = 4;
	138	netBoot32 =
	139	AllocateBootXMemory(kNetBootWidth * kNetBootHeight * kNetBootFrames * 4);
	140	for (cnt = 0; cnt < (kNetBootWidth * kNetBootHeight * kNetBootFrames); cnt++)
	141	netBoot32[cnt] = LookUpCLUTIndex(gNetBootPict[cnt], 32);
	142	gNetBoot = (char *)netBoot32;
	143	break;
	144
	145	default :
	146	pixelSize = 1;
	147	gNetBoot = (unsigned char *)gNetBootPict;
	148	break;
	149	}
04fee52e	150
366defd1 A	151	x = (display->width - kNetBootWidth) / 2;
366defd1 A	152	y = (display->height - kNetBootHeight) / 2 + kNetBootOffset;
04fee52e	153
366defd1 A	154	CallMethod(5, 0, display->screenIH, "draw-rectangle", (long)gNetBoot,
366defd1 A	155	x, y, kNetBootWidth, kNetBootHeight);
04fee52e	156
366defd1 A	157	// Set up the spin cursor.
	158	SpinInit(display->screenIH, gNetBoot,
	159	x, y,
	160	kNetBootWidth, kNetBootHeight,
	161	kNetBootFrames, kNetBootFPS, pixelSize, 0);
	162	}
	163	break;
	164
	165	case 1 :
	166	x = (display->width - kAppleBootWidth) / 2;
	167	y = (display->height - kAppleBootHeight) / 2 + kAppleBootOffset;
	168
	169	CallMethod(5, 0, display->screenIH, "draw-rectangle", (long)gAppleBoot,
	170	x, y, kAppleBootWidth, kAppleBootHeight);
	171
	172	if (gBootFileType == kNetworkDeviceType) {
	173	x = (display->width - kNetBootWidth) / 2;
	174	y = (display->height - kNetBootHeight) / 2 + kNetBootOffset;
04fee52e	175
366defd1 A	176	// Erase the netboot picture with 75% grey.
	177	CallMethod(5, 0, display->screenIH, "fill-rectangle",
	178	LookUpCLUTIndex(0x01, display->depth),
	179	x, y, kNetBootWidth, kNetBootHeight);
04fee52e	180	}
366defd1	181	break;
04fee52e	182
366defd1 A	183	default :
	184	return -1;
	185	break;
04fee52e	186	}
04fee52e A	187
	188	return 0;
	189	}
	190
	191
366defd1	192	long DrawFailedBootPicture(void)
04fee52e A	193	{
04fee52e A	194	long cnt;
366defd1 A	195	short *failedBoot16;
366defd1 A	196	long *failedBoot32, posX, posY;
04fee52e A	197	DisplayInfoPtr display = &gDisplays[gMainDisplayNum];
04fee52e A	198
04fee52e A	199	switch (display->depth) {
04fee52e A	200	case 16 :
366defd1	201	failedBoot16 = AllocateBootXMemory(32 * 32 * 2);
04fee52e	202	for (cnt = 0; cnt < (32 * 32); cnt++)
366defd1 A	203	failedBoot16[cnt] = LookUpCLUTIndex(gFailedBootPict[cnt], 16);
366defd1 A	204	gFailedBoot = (char *)failedBoot16;
04fee52e A	205	break;
	206
	207	case 32 :
366defd1	208	failedBoot32 = AllocateBootXMemory(32 * 32 * 4);
04fee52e	209	for (cnt = 0; cnt < (32 * 32); cnt++)
366defd1 A	210	failedBoot32[cnt] = LookUpCLUTIndex(gFailedBootPict[cnt], 32);
366defd1 A	211	gFailedBoot = (char *)failedBoot32;
04fee52e A	212	break;
	213
	214	default :
366defd1	215	gFailedBoot = (unsigned char *)gFailedBootPict;
04fee52e A	216	break;
	217	}
	218
366defd1 A	219	// Erase the newboot picture with 75% grey.
	220	posX = (display->width - kNetBootWidth) / 2;
	221	posY = (display->height - kNetBootHeight) / 2 + kNetBootOffset;
	222	CallMethod(5, 0, display->screenIH, "fill-rectangle",
	223	LookUpCLUTIndex(0x01, display->depth),
	224	posX, posY, kNetBootWidth, kNetBootHeight);
	225
	226	// Draw the failed boot picture.
	227	posX = (display->width - kFailedBootWidth) / 2;
	228	posY = ((display->height - kFailedBootHeight)) / 2 + kFailedBootOffset;
	229	CallMethod(5, 0, display->screenIH, "draw-rectangle",
	230	(long)gFailedBoot, posX, posY,
	231	kFailedBootWidth, kFailedBootHeight);
04fee52e A	232
	233	return 0;
	234	}
	235
	236
	237	void GetMainScreenPH(Boot_Video_Ptr video)
	238	{
	239	DisplayInfoPtr display;
366defd1	240	long address, size;
04fee52e A	241
	242	if (gMainDisplayNum == -1) {
	243	// No display, set it to zero.
	244	video->v_baseAddr = 0;
	245	video->v_rowBytes = 0;
	246	video->v_width = 0;
	247	video->v_height = 0;
	248	video->v_depth = 0;
	249	} else {
	250	display = &gDisplays[gMainDisplayNum];
	251
	252	video->v_baseAddr = display->address;
	253	video->v_rowBytes = display->linebytes;
	254	video->v_width = display->width;
	255	video->v_height = display->height;
	256	video->v_depth = display->depth;
	257	}
366defd1 A	258
	259	// Allocate memory and a range for the CLUT.
	260	size = 256 * 3;
	261	address = AllocateKernelMemory(size);
	262	AllocateMemoryRange("BootCLUT", address, size);
	263	bcopy((char )gClut, (char )address, size);
	264
	265	// Allocate memory and a range for the failed boot picture.
	266	size = 32 + kFailedBootWidth * kFailedBootHeight;
	267	address = AllocateKernelMemory(size);
	268	AllocateMemoryRange("Pict-FailedBoot", address, size);
	269	((long *)address)[0] = kFailedBootWidth;
	270	((long *)address)[1] = kFailedBootHeight;
	271	((long *)address)[2] = kFailedBootOffset;
	272	bcopy((char )gFailedBootPict, (char )(address + 32), size - 32);
04fee52e A	273	}
04fee52e A	274
366defd1	275
04fee52e A	276	// Private Functions
	277
	278	static long FindDisplays(void)
	279	{
	280	CICell screenPH, controlPH;
	281	long cnt;
	282
	283	// Find all the screens in the system.
	284	screenPH = 0;
	285	while (1) {
	286	screenPH = SearchForNode(screenPH, 1, "device_type", "display");
	287	if (screenPH != 0) gDisplays[gNumDisplays++].screenPH = screenPH;
	288	else break;
	289	}
	290
	291	// Find /chaos/control, and
	292	// invalidate gStdOutPH if equal (since new OF was downloaded).
	293	controlPH = FindDevice("/chaos/control");
	294	if (gStdOutPH == controlPH) gStdOutPH = 0;
	295
	296	// Find the main screen using the screen alias or chaos/control.
	297	gMainDisplayNum = -1;
	298	screenPH = FindDevice("screen");
	299	if (screenPH == -1) screenPH = controlPH;
	300	for (cnt = 0; cnt < gNumDisplays; cnt++)
	301	if (gDisplays[cnt].screenPH == screenPH) gMainDisplayNum = cnt;
	302
	303	return 0;
	304	}
	305
	306
	307	static long OpenDisplays(void)
	308	{
	309	long cnt;
	310
	311	// Open the main screen or
	312	// look for a main screen if we don't have one.
	313	if ((gMainDisplayNum == -1) \|\| !OpenDisplay(gMainDisplayNum)) {
	314	gMainDisplayNum = -1;
	315	for (cnt = 0; cnt < gNumDisplays; cnt++) {
	316	if (OpenDisplay(cnt)) {
	317	gMainDisplayNum = cnt;
	318	break;
	319	}
	320	}
	321	}
	322
853f9ac3 A	323	// Open the rest of the displays
	324	if (gOFVersion >= kOFVersion3x) {
	325	for (cnt = 0; cnt < gNumDisplays; cnt++) {
	326	OpenDisplay(cnt);
	327	}
	328	}
	329
04fee52e A	330	return 0;
	331	}
	332
04fee52e A	333
	334	static long OpenDisplay(long displayNum)
	335	{
366defd1 A	336	char screenPath[258], displayType[32];
	337	CICell screenPH, screenIH;
	338	long ret, size;
04fee52e	339
853f9ac3 A	340	// Only try to open a screen once.
	341	if (gDisplays[displayNum].triedToOpen) {
	342	return gDisplays[displayNum].screenIH != 0;
	343	} else {
	344	gDisplays[displayNum].triedToOpen = -1;
	345	}
	346
366defd1 A	347	screenPH = gDisplays[displayNum].screenPH;
366defd1 A	348
04fee52e	349	// Try to use mac-boot's ihandle.
366defd1 A	350	Interpret(0, 1, "\" _screen-ihandle\" $find if execute else 0 then",
	351	&screenIH);
	352	if ((screenIH != 0) && (InstanceToPackage(screenIH) != screenPH)) {
853f9ac3 A	353	screenIH = 0;
853f9ac3 A	354	}
04fee52e A	355
04fee52e A	356	// Try to use stdout as the screen's ihandle
366defd1	357	if ((screenIH == 0) && (gStdOutPH == screenPH)) {
853f9ac3 A	358	screenIH = gStdOutIH;
853f9ac3 A	359	}
04fee52e A	360
	361	// Try to open the display.
	362	if (screenIH == 0) {
	363	screenPath[255] = '\0';
366defd1	364	ret = PackageToPath(screenPH, screenPath, 255);
04fee52e	365	if (ret != -1) {
853f9ac3	366	strcat(screenPath, ":0");
04fee52e A	367	screenIH = Open(screenPath);
	368	}
	369	}
	370
366defd1 A	371	// Find out what type of display is attached.
	372	size = GetProp(screenPH, "display-type", displayType, 31);
	373	if (size != -1) {
	374	displayType[size] = '\0';
	375	// If the display-type is NONE, don't use the display.
	376	if (!strcmp(displayType, "NONE")) screenIH = 0;
	377	}
	378
04fee52e A	379	// Save the ihandle for later use.
	380	gDisplays[displayNum].screenIH = screenIH;
	381
	382	// Initialize the display.
	383	if (screenIH != 0) InitDisplay(displayNum);
	384
	385	return screenIH != 0;
	386	}
	387
	388
	389	static long InitDisplay(long displayNum)
	390	{
	391	DisplayInfoPtr display = &gDisplays[displayNum];
	392	CICell screenPH = display->screenPH;
	393	CICell screenIH = display->screenIH;
	394
	395	// Get the vital info for this screen.
	396	GetProp(screenPH, "address", (char *)&(display->address), 4);
	397	GetProp(screenPH, "width", (char *)&(display->width), 4);
	398	GetProp(screenPH, "height", (char *)&(display->height), 4);
	399	GetProp(screenPH, "depth", (char *)&(display->depth), 4);
	400	GetProp(screenPH, "linebytes", (char *)&(display->linebytes), 4);
	401
	402	// Replace some of the drivers words.
366defd1	403	Interpret(3, 1,
04fee52e	404	" value depthbytes"
366defd1 A	405	" value rowbytes"
366defd1 A	406	" to active-package"
853f9ac3	407	" frame-buffer-adr value this-frame-buffer-adr"
04fee52e A	408
04fee52e A	409	" : rect-setup" // ( adr\|index x y w h -- w adr\|index xy-adr h )
853f9ac3	410	" >r >r rowbytes * swap depthbytes * + this-frame-buffer-adr +"
04fee52e A	411	" r> depthbytes * -rot r>"
	412	" ;"
	413
	414	" : DRAW-RECTANGLE" // ( adr x y w h -- )
	415	" rect-setup" // ( w adr xy-adr h )
	416	" 0 ?do" // ( w adr xy-adr )
	417	" 2dup 4 pick move"
	418	" 2 pick rowbytes d+"
	419	" loop"
	420	" 3drop"
	421	" ;"
	422
	423	" : FILL-RECTANGLE" // ( index x y w h -- )
	424	" rect-setup rot depthbytes case"
	425	" 1 of dup 8 << or dup 10 << or endof"
	426	" 2 of dup 10 << or endof"
	427	" endcase -rot 0 ?do"
	428	" dup 3 pick 3 pick filll"
	429	" rowbytes +"
	430	" loop"
	431	" 3drop"
	432	" ;"
	433
	434	" : READ-RECTANGLE" // ( adr x y w h -- )
	435	" rect-setup >r swap r> 0 ?do"
	436	" 2dup 4 pick move"
	437	" rowbytes 3 pick d+"
	438	" loop"
	439	" 3drop"
	440	" ;"
	441
853f9ac3	442	" this-frame-buffer-adr"
04fee52e A	443	" 0 to active-package"
	444	, display->screenPH, display->linebytes,
	445	display->depth / 8, &display->address);
	446
366defd1	447	// Set the CLUT for 8 bit displays.
04fee52e	448	if (display->depth == 8) {
366defd1	449	CallMethod(3, 0, screenIH, "set-colors", (long)gClut, 0, 256);
04fee52e A	450	}
04fee52e A	451
366defd1 A	452	// Set the screen to 75% grey.
	453	CallMethod(5, 0, screenIH, "fill-rectangle",
	454	LookUpCLUTIndex(0x01, display->depth),
	455	0, 0, display->width, display->height);
04fee52e A	456
	457	return 0;
	458	}
	459
	460
	461	static long LookUpCLUTIndex(long index, long depth)
	462	{
	463	long result, red, green, blue;
	464
	465	red = gClut[index * 3 + 0];
	466	green = gClut[index * 3 + 1];
	467	blue = gClut[index * 3 + 2];
	468
	469	switch (depth) {
	470	case 16 :
	471	result = ((red & 0xF8) << 7)\|((green & 0xF8) << 2)\|((blue & 0xF8) >> 3);
	472	break;
	473
	474	case 32 :
	475	result = (red << 16) \| (green << 8) \| blue;
	476	break;
	477
	478	default :
	479	result = index;
	480	break;
	481	}
	482
	483	return result;
	484	}
853f9ac3	485
366defd1	486
853f9ac3	487	#if 0
366defd1 A	488	static void DumpDisplaysInfo(void);
	489
	490	static void DumpDisplaysInfo(void)
853f9ac3	491	{
366defd1 A	492	long cnt, length;
366defd1 A	493	char tmpStr[512];
853f9ac3	494
366defd1 A	495	printf("gNumDisplays: %x, gMainDisplayNum: %x\n",
	496	gNumDisplays, gMainDisplayNum);
	497
	498	for (cnt = 0; cnt < gNumDisplays; cnt++) {
	499	printf("Display: %x, screenPH: %x, screenIH: %x\n",
	500	cnt, gDisplays[cnt].screenPH, gDisplays[cnt].screenIH);
853f9ac3	501
366defd1 A	502	if (gDisplays[cnt].screenPH) {
	503	length = PackageToPath(gDisplays[cnt].screenPH, tmpStr, 511);
	504	tmpStr[length] = '\0';
	505	printf("PHandle Path: %s\n", tmpStr);
	506	}
853f9ac3	507
366defd1 A	508	if (gDisplays[cnt].screenIH) {
	509	length = InstanceToPath(gDisplays[cnt].screenIH, tmpStr, 511);
	510	tmpStr[length] = '\0';
	511	printf("IHandle Path: %s\n", tmpStr);
	512	}
853f9ac3	513
366defd1 A	514	printf("address = %x\n", gDisplays[cnt].address);
	515	printf("linebytes = %x\n", gDisplays[cnt].linebytes);
	516	printf("width = %x\n", gDisplays[cnt].width);
	517	printf("height = %x\n", gDisplays[cnt].height);
	518	printf("depth = %x\n", gDisplays[cnt].depth);
	519	printf("\n");
853f9ac3	520	}
853f9ac3 A	521	}
853f9ac3 A	522	#endif