Macintosh-SW
/
mac-rom
mirror of https://github.com/elliotnunn/mac-rom.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mac-rom/Drivers/Backlight/Register.c

519 lines
15 KiB
C
Raw Blame History

/*
File: register.c
Contains: Register control for backlight.
Written by: Andy Gong x6595
Copyright: © 1991-1993 by Apple Computer, Inc., all rights reserved.
Change History (most recent first):
<SM5> 12/13/93 PN Roll in KAOs and Horror changes to support Malcom and AJ
machines
<SM4> 2/11/93 CSS Update from Horror. Comments follow:
<H4> 6/30/92 ag Moved cpu depended initialization code to cpu.c file, and input
routines to input.c.
<H3> 5/7/92 ag Use new table record for min/max limits.
<H2> 4/24/92 ag return error from initialization.
<2> 3/23/92 JSM OSEvents.h is obsolete, use Events.h.
<1> 10/24/91 SAM/KSM Rolled in Regatta file.
Regatta Change History:
<8> 8/21/91 SAM Undid the last mod. Using GetKeys again.
<7> 8/19/91 SAM (ag) added a key repeat delay to the key processing stuff.
<6> 7/30/91 SAM (ag) removed special initialization code in set brightness,
changed type of pram value to int to allow for negative error
check.
<5> 7/18/91 SAM (ag) cleaned up initialization code.
<4> 6/30/91 SAM Merged from TERROR [<5>].
<3> 6/14/91 SAM (ag) added support in set level routine to handle passing in an
illegal value as a flag to indicated initialization. Changed low
power handling, get input and set output routines will key off
of power state.
<1> 5/15/91 SAM Split off from TERRORProj.
Terror Change History:
<5> 6/24/91 ag Changed init code to initialize to user value. Changed calling
structure for setting backlight. Changed lookup tables to byte
size elements.
<4> 6/10/91 ag Changed low power handling, get input and set output routines
will key off of power state.
<3> 5/10/91 ag added support in set level routine to handle passing in an
illegal value as a flag to indicated initialization.
<2> 4/23/91 ag cleaned up init code, moved initial code to main (backlight.c).
*/
#define PORTABLE_HW 0xFC0202
/*page*/
/************************************/
/*** INCLUDE FILES DECLARATIONS ***/
#include <SysEqu.h>
#include <types.h>
#include <traps.h>
#include <memory.h>
#include <Events.h>
#include <OSUtils.h>
#include <devices.h>
#include <errors.h>
#include <Shutdown.h>
#include <Stdlib.h>
#include "PowerMgr.h"
#include "backlight.h"
void SleepEntry();
// *** backlight stuff
#define ON_BIT 0x02 /* 0 = off, 1 = on*/
#define L_CS_BIT 0x20 /* 0 = select chip to accept data */
#define COUNTDN_BIT 0x40 /* 0 = down, 1 = up */
#define COUNT_BIT 0x80 /* 1 - 0 - 1 pulsed to count */
#define ALL_BITS COUNT_BIT + COUNTUP_BIT + L_CS_BIT
#define SELECT(backlightreg,value) value &= (~L_CS_BIT); *backlightreg = value
#define DESELECT(backlightreg,value) value |= L_CS_BIT ; *backlightreg = value
#define MAXSTROBECOUNT 256
#define MAXPOTVALUE 255 /* maximum value of digital pot */
#define MINPOTVALUE 0 /* maximum value of digital pot */
/* brightness boundaries */
#define kMaxBrightness 30 /* <5> maximum brightness */
#define kMinBrightness 0 /* minimum brightness */
#define REPEATTIME 5
#define REPEATTHRESHOLD 1
#define BACKLIGHT_ON true
#define BACKLIGHT_OFF false
#define SLEEPQELEMENTTYPE 16
// *** keyboard stuff
#define KEYDOWNTEST(keynum,map) (map[keynum >> 3] & (1 << (keynum % 8)))
#define KEYDOWNBYTETEST(bytenum,keymask,map) (map[bytenum] & keymask)
#define UPARROW 0x7E
#define DOWNARROW 0x7D
#define RIGHTARROW 0x7C
#define LEFTARROW 0x7B
#define BYTEMASK_7_CTL 0x88
#define BYTEMASK_7_OPT 0x44
#define BYTEMASK_7_SFT 0x11
typedef struct
{
long oldvector;
char keysActive;
char keymodifiers;
short unused;
} posteventtype, *posteventtypeptr;
extern setTableType PortableTbl5V;
int GetBacklightInfo(short mask, short shift);
void SaveBacklightInfo(short new,short mask, short shift);
TurnOnOff(Boolean on);
setNewKeys(int keycombo);
/*page
***************************************************************************************************
** Register control software **********************************************************************
***************************************************************************************************
*/
OSErr InitRegControls(driverGlobalPtr globalPtr)
{
int SetBrightness();
int KbdControl();
int RegisterClose();
unsigned int pramBrightness;
void ShutdownBacklight();
if (BACKLIGHTSIGREG & TABLE_5V) globalPtr->settingTable = &PortableTbl5V;
globalPtr->keycodes = GetPramKeyData();
pramBrightness = GetPramBrightness(); /* get pram setting */
setNewKeys(globalPtr->keycodes);
if (pramBrightness < 0) /* check for valid brightness value */
{
pramBrightness = globalPtr->settingTable->minimum+1; /* <H3> load default brightness */
SaveBrightness(globalPtr->settingTable->minimum+1); /* <H3> validate, as save new brightness */
};
globalPtr->userBrightness = globalPtr->settingTable->maximum; /* <H3> */
globalPtr->userBrightness = SetBrightness(globalPtr->settingTable->minimum,globalPtr); /* <H3> initialize pot */
globalPtr->userBrightness = SetBrightness(pramBrightness,globalPtr); /* set brightness level */
if (BACKLIGHTSIGREG == BACKLIGHTSIG_UPGRD)
{
globalPtr->sleepQelement.sleepQType = SLEEPQELEMENTTYPE;
globalPtr->sleepQelement.sleepQProc = (ProcPtr) SleepEntry;
SleepQInstall(&globalPtr->sleepQelement); /* install sleep task */
};
ShutDwnInstall( (ShutDwnProcPtr) ShutdownBacklight,sdRestartOrPower); /* install shutdown task */
return(noErr);
};
/*page
***************************************************************************************************
*
*
***************************************************************************************************
*/
void StrobeCount(char *backlightreg, int number, unsigned char value)
{
int index;
if (!number) return; /* return if no strobes */
value |= COUNT_BIT; /* start with count inactive */
for (index = (number << 1); index; index--) /* <15> write twice for each pulse <90/08/01>*/
{
value ^= COUNT_BIT; /* toggle count bit */
*backlightreg = value; /* write value */
}
};
/*page
***************************************************************************************************
*
*
***************************************************************************************************
*/
void ShutdownBacklight()
{
TurnOnOff(BACKLIGHT_OFF);
};
/*page
***************************************************************************************************
*
* This sleep task is necessary due to the fact CPU hardware changed the design of the board and
* power to the backlight is nolonger turned off by the hardware at sleep or shutdown (yuck!).
* Therefore software MUST turn off the backlight for now. ( 90/07/20 ag )
*
*
***************************************************************************************************
*/
void Sleep_Task(driverGlobalPtr globalPtr, int selector)
{
#define SLEEPQELEMENTTYPE 16
#define SLEEP_REQUEST 1
#define SLEEP_DEMAND 2
#define SLEEP_WAKEUP 3
#define SLEEP_REQ_ABORT 4
switch (selector)
{
case SLEEP_DEMAND:
globalPtr->vbl_ok = false;
TurnOnOff(BACKLIGHT_OFF);
break;
case SLEEP_WAKEUP:
if (globalPtr->userBrightness) TurnOnOff(BACKLIGHT_ON);
globalPtr->vbl_ok = true;
break;
case SLEEP_REQ_ABORT:
case SLEEP_REQUEST:
default:
break;
};
};
/*
***************************************************************************************************
*
*
***************************************************************************************************
*/
TurnOnOff(Boolean on)
{
unsigned char regvalue;
char *backlightreg;
Boolean onBitHigh;
backlightreg = (Ptr) PORTABLE_HW;
onBitHigh = (BACKLIGHTSIGREG & ON_HIGH);
regvalue = COUNT_BIT + L_CS_BIT; /* start with count and CS inactive */
if ((onBitHigh && on) || (!onBitHigh && !on))
regvalue |= ON_BIT; /* upgrade has opposite polarity */
*backlightreg = regvalue; /* write value */
};
/*page
***************************************************************************************************
*
*
***************************************************************************************************
*/
int SetBrightness(int new, driverGlobalPtr globalPtr)
{
unsigned char regvalue;
int strobes;
char *backlightreg;
char signature;
Boolean onBitHigh;
Boolean countDownBit;
int current;
unsigned char tablevalue;
Boolean initialize;
initialize = (globalPtr->userBrightness < 0);
PEG_TO_LIMITS(new, globalPtr->maximumTable[globalPtr->powerRange], globalPtr->settingTable->minimum); /* <H3> limit value to valid range */
current = (initialize)
? globalPtr->settingTable->minimum /* <H3> */
: globalPtr->userBrightness;
tablevalue = globalPtr->settingTable->table[new]; /* <H3> look up value from table */
if (!initialize && (tablevalue == globalPtr->lastHWSetting) )
return(new); /* nothing to do; 90/05/15 just turn on; 90/07/02 avoid touching */
/* setup control bits */
signature = BACKLIGHTSIGREG;
onBitHigh = (signature & ON_HIGH);
countDownBit = (signature & COUNT_DWNBIT);
backlightreg = (Ptr) PORTABLE_HW;
regvalue = COUNT_BIT + L_CS_BIT; /* start with count and CS inactive */
if ((onBitHigh && (new != globalPtr->settingTable->minimum)) || (!onBitHigh && (new == globalPtr->settingTable->minimum))) /* <H3> */
regvalue |= ON_BIT; /* upgrade has opposite polarity */
if ((countDownBit && (new <= current)) || (!countDownBit && (new >= current)))
regvalue |= COUNTDN_BIT; /* set the count down bit if new > current */
strobes = (new == globalPtr->settingTable->minimum) /* <H3> */
? MAXSTROBECOUNT /* if minimum, bang against stops */
: abs(globalPtr->lastHWSetting - tablevalue);
SELECT(backlightreg,regvalue); /* assert chip select */
StrobeCount(backlightreg,strobes,regvalue); /* strobe count line */
DESELECT(backlightreg,regvalue); /* deassert chip select */
globalPtr->lastHWSetting = tablevalue; /* save the hardware setting */
return(new);
};
/*page
***************************************************************************************************
*
* bit 2 1 0
* +-----+-----+-----+
* | | | |
* | opt | sft | ctl |
* | | | |
* +-----+-----+-----+
*
* 90/12/18 ag recoded key down check.
*
*
*
***************************************************************************************************
*/
Boolean KeysDown(int value, char kbdmap[])
{
#define CONTROLBIT 0x01;
#define SHIFTBIT 0x02;
#define OPTIONBIT 0x04;
int keysDown;
if (!value) return (false); /* no key combinations */
keysDown = 0;
if (kbdmap[7] & BYTEMASK_7_CTL) keysDown += CONTROLBIT;
if (kbdmap[7] & BYTEMASK_7_SFT) keysDown += SHIFTBIT;
if (kbdmap[7] & BYTEMASK_7_OPT) keysDown += OPTIONBIT;
return((keysDown == value));
};
/*page
***************************************************************************************************
*
*
***************************************************************************************************
*/
int KbdControl (driverGlobalPtr globalPtr)
{
char kbdmap[16];
int delta;
int returnValue;
int maximum;
returnValue = globalPtr->userBrightness;
maximum = globalPtr->maximumTable[globalPtr->powerRange];
if (globalPtr->userBrightness > maximum)
return(maximum);
GetKeys((KeyMap) &kbdmap[0]);
// postdataptr = &postEventData;
// if (!postdataptr->keysActive)
if (!KeysDown(globalPtr->keycodes,kbdmap))
{
globalPtr->mousedownTicks = 0; /* no mouse event */
globalPtr->kbdactive = false; /* kbd control cancel */
}
else
{
globalPtr->mousedownTicks += 1; /* increment mouse down time */
if (globalPtr->mousedownTicks > ((globalPtr->kbdactive) ? REPEATTIME : REPEATTHRESHOLD) )
{
globalPtr->kbdactive = true;
globalPtr->mousedownTicks = 1;
delta = 0;
if (KEYDOWNTEST(UPARROW,kbdmap) || KEYDOWNTEST(RIGHTARROW,kbdmap)) delta = 1;
if (KEYDOWNTEST(DOWNARROW,kbdmap) || KEYDOWNTEST(LEFTARROW,kbdmap)) delta = -1;
if ((globalPtr->userBrightness+delta) > maximum)
delta = 0;
if ((globalPtr->userBrightness+delta) < 0 )
delta = 0;
returnValue = globalPtr->userBrightness + delta;
};
};
return(returnValue);
};
/*page
***************************************************************************************************
*
*
***************************************************************************************************
*/
int RegisterClose (driverGlobalPtr globalPtr)
{
globalPtr->userBrightness = globalPtr->settingTable->maximum; /* <H3> */
globalPtr->userBrightness = SetBrightness(globalPtr->settingTable->minimum,globalPtr); /* <H3> initialize pot */
SleepQRemove(&globalPtr->sleepQelement); /* remove sleep task */
ShutDwnRemove( (ShutDwnProcPtr) ShutdownBacklight); /* remove shutdown task */
// NSetTrapAddress(postdataptr->oldvector,_PostEvent,OSTrap);
return(0);
};
/*page
***************************************************************************************************
*
* The control routineÉ
*
* return:
* noErr - task completed successfully
* controlErr - illegal control selector
*
*
***************************************************************************************************
*/
OSErr RegisterControl(CntrlParam *ctlPB,driverGlobalPtr globalPtr) /* 'open' entry point */
{
#pragma unused (ctlPB)
int error;
int tempvalue;
error = noErr;
switch(ctlPB->csCode)
{
case kSetScreenBrightness: /* set brightness level */
tempvalue = ctlPB->csParam[0];
globalPtr->userBrightness = (*globalPtr->setlevelproc)(tempvalue,globalPtr);
break;
case kSaveScreenBrightness: /* save brightness level */
SaveBrightness(globalPtr->userBrightness);
break;
case kSetBrightnessKeys:
tempvalue = ctlPB->csParam[0];
globalPtr->keycodes = tempvalue & KEY_VALUE_MASK; /* limit value to key code range */
setNewKeys(globalPtr->keycodes);
break;
case kSavePKeys:
SaveKeyData(globalPtr->keycodes);
break;
default:
error = controlErr;
};
return(error);
};
/*page
***************************************************************************************************
*
* The status routineÉ
*
* return:
* noErr - task completed successfully
* statusErr - illegal control selector
*
***************************************************************************************************
*/
OSErr RegisterStatus(CntrlParam *ctlPB,driverGlobalPtr globalPtr) /* 'open' entry point */
{
short error;
error = noErr;
switch(ctlPB->csCode)
{
case kGetBrightnessKeys: /* return current saved brightness */
ctlPB->csParam[0] = globalPtr->keycodes;
break;
case kGetPBacklight:
ctlPB->csParam[0] = GetPramBrightness();
break;
case kGetPKey:
ctlPB->csParam[0] = GetPramKeyData();
break;
default:
error = statusErr;
};
return(error);
}
setNewKeys(int keycombo)
{
char newKey;
newKey = 0;
if (keycombo & 0x01) newKey |= 0x10;
if (keycombo & 0x02) newKey |= 0x02;
if (keycombo & 0x04) newKey |= 0x08;
};
Reference in New Issue View Git Blame Copy Permalink