mirror of
https://github.com/elliotnunn/supermario.git
synced 2025-02-18 12:30:31 +00:00
5195 lines
241 KiB
Plaintext
5195 lines
241 KiB
Plaintext
;
|
||
; File: PowerMgrPrimitives.a
|
||
;
|
||
; Contains: low-level routines for managing Power Management tasks
|
||
;
|
||
; Written by: Helder J. Ramalho
|
||
;
|
||
; Copyright: © 1992-1993 by Apple Computer, Inc. All rights reserved.
|
||
;
|
||
; This file is used in these builds: ROM
|
||
;
|
||
; Change History (most recent first):
|
||
;
|
||
; <SM8> 12/13/93 PN Roll in KAOs and Horror changes to support Malcom and AJ
|
||
; machines.
|
||
; <SM7> 9/17/93 KH I'm not Eva (EH), but this BBS installation is apparently
|
||
; screwed up.
|
||
; <SM6> 9/17/93 SKH Fix a bug with sleep. Don't use A3 to acces PMgr globals, use
|
||
; A2. (SaveSleepInfo)
|
||
; <SM5> 8/4/93 JDR Private sound defines were moved to SoundPrivate.a.
|
||
; <SM4> 01-12-93 jmp Changed name from drHwDBLite to the more appropriate drHwGSC.
|
||
; <SM3> 11/20/92 SWC Rolled in the rest of the Horror changes.
|
||
; <H44> 8/13/92 SWC Changed GetExtLevel to change warning levels at the 1/3 and 2/3
|
||
; levels instead of at the x/4 levels so we get better spaced
|
||
; warnings.
|
||
; <H43> 8/4/92 SWC Save and restore the current GrafPort around the call to
|
||
; PaintBehind since PaintBehind will clobber it. This was causing
|
||
; the screen to be incorrectly updated (portions remained gray).
|
||
; <H42> 7/27/92 SWC Point to the correct SendSleep routine for DBLite (we
|
||
; distinguish between a normal and low power sleep).
|
||
; <H41> 7/23/92 SWC Fixed a bug in GetExtLevel that was keeping us from displaying
|
||
; low power messages.
|
||
; <H40> 7/22/92 SWC In SaveMSC, turn on IOClk before we go to sleep in case a bar is
|
||
; added during sleep so that the clock will be running as soon as
|
||
; power is turned back on. If it turns out no bar is attached, the
|
||
; Docking Manager will turn this back off.
|
||
; <H39> 7/14/92 ag Change the LeadScaledBattery routine to use globals and avoid
|
||
; hitting the power manager. Instead of current battery level,
|
||
; use averaged battery level.
|
||
; <H38> 7/14/92 djw (HJR) Remove NiagraChkIdle since it is not used.
|
||
; <H37> 7/14/92 SWC Hopefully I finally got the scaled battery stuff working (those
|
||
; Dart guys will be mighty pissed if we need to do a patch...).
|
||
; <H36> 7/14/92 HJR Modify dimming so that a screen update will only occur if some
|
||
; device supported the LowPwrSelect control call.
|
||
; <H35> 7/13/92 HJR Fix a bug in Dimming where if External Monitor is startup
|
||
; device, internal display does not unblank itself after dimming.
|
||
; Problem was that A0=IOPB was being trashed by PaletteDispatch.
|
||
; <H34> 7/13/92 HJR Rewrote External monitor alerts so that if an External Monitor
|
||
; Alert is displayed, the charger state will not remove alert.
|
||
; Added ChkDimming so that DBlite may use it more readily.
|
||
; <H33> 7/13/92 ag Added constants to the info tables for delay time before shorted
|
||
; battery dialog and delta battery warn level if external monitor
|
||
; is being used.
|
||
; <H32> 7/11/92 HJR Rewrote VidLowPwrSelect so that it runs throught the device list
|
||
; and powers down all available screens. Cleaned up things here
|
||
; and there.
|
||
; <H31> 7/10/92 ag added modem primitive tables and routines. added vectorize
|
||
; shutdown with retry.
|
||
; <H30> 7/1/92 ag Clear sound power control before turning on power amps.
|
||
; <H29> 7/1/92 ag Add code to turn off power to sound circuits controlled by ponti
|
||
; asic during sleep. Added power amplifiers controls to niagra
|
||
; sleep and wake routines.
|
||
; <H28> 6/30/92 HJR In SaveGSC and RestoreGSC, call the driver to Blank the screen
|
||
; on going to sleep and grey the screen on wakeup.
|
||
; <H27> 6/25/92 SWC Fixed the clamshell logic (was crashing if a docking bar
|
||
; prevented sleep). We no longer shutdown on clamshell close since
|
||
; that had a lot of problems. Upped the padding size to 8K since
|
||
; we're getting full (and more stuff is expected. :)
|
||
; <H26> 6/11/92 djw Modify PostUserNmMsg to accept completion routine parameter.
|
||
; Add code to check for posting a warning msg based on a flag set
|
||
; by the external video's primaryInit (if no charger attached) in
|
||
; NiagraRunIdleRoutineProc.
|
||
; <H25> 6/10/92 HJR Disable GDevice when dimming and fix bug where if external
|
||
; device is main device, bus error occurs after dimming.
|
||
; <H24> 6/9/92 ag change the batman save and restore code the the one used on
|
||
; terror. The order which things are done is very critical. if you
|
||
; must change the code, do so carefully.
|
||
; <H23> 6/5/92 SWC Finished up the scaled battery info routines.
|
||
; <H22> 6/2/92 djw Added check for external video without a charger in
|
||
; NiagraRunIdleRoutineProc. If condition found, post alert to the
|
||
; user. Added PostUserNmMsg utility routine.
|
||
; <H21> 6/1/92 HJR Disable GDevice if we are powering down the device.
|
||
; <H20> 5/19/92 HJR Generalized IdleMindTable with RunIdleRoutines so that various
|
||
; miscellaneous routines can be localized. Add
|
||
; NiagraRunIdleRoutineProc which now check whether to power down
|
||
; screens.
|
||
; <H19> 5/15/92 SWC Added the battery and sound monitoring VBL tasks to the list of
|
||
; primitives for each machine, and moved SndWatch and
|
||
; SndWatchPonti here from PowerMgr.a.
|
||
; <H18> 5/8/92 SWC Fixed a copy/paste typo in the MSC table that could cause a
|
||
; crash. Removed CPUSpeedNiagraRead since it's no longer used.
|
||
; <H17> 5/7/92 HJR Added primitives for WakeScreenRefresh and necessary code for
|
||
; VSCPowerSelect. Rewrote CPUSpeedNiagra to that it matches
|
||
; hardware. Blank GSC during wakeup.
|
||
; <H16> 5/7/92 ag Added softshutdown to Dartanian timeout checks.
|
||
; <H15> 5/7/92 SWC Added primitives to return a scaled battery level so the Battery
|
||
; DA, etc., won't have to be rev'd each time we do a new portable.
|
||
; Added a check to ChkHDSpinDown to prevent the hard disk from
|
||
; being spun down if we're connected to a docking station (AC
|
||
; power is assumed).
|
||
; <SM2> 11/19/92 SWC Exported the primitives tables so they can be used in
|
||
; UniversalTables.a. Changed ShutdownEqu.a->Shutdown.a.
|
||
; <1> 5/17/92 kc first checked in
|
||
; <SM0> 5/2/92 kc Roll in Horror. Comments follow:
|
||
; <H14> 4/24/92 HJR Updated NiagraChkIdle for current state of hardware. Changed
|
||
; PRAM base in NiagraPrimInfo to $46 since slot E is now needed
|
||
; for VSC.
|
||
; <H13> 4/17/92 SWC Added a check to GetExtLevel to see if the charger is connected
|
||
; since the returned battery voltage will be zero if we're running
|
||
; without a battery (causing the system to go to sleep all the
|
||
; time).
|
||
; <H12> 4/13/92 SWC Modified GetExtLevel to actually check for the existance of a
|
||
; battery. Zeroed the MSC default battery warning level values
|
||
; since they'll change depending on what kind of battery is
|
||
; connected. The PMGR will determine what these should be each
|
||
; time a new battery type is installed.
|
||
; <H11> 4/8/92 SWC Fixed a bug in the clamshell switch check.
|
||
; <H10> 3/20/92 SWC Added calls to DockingSleep and DockingWakeup to DBLite's sleep
|
||
; and wakeup tables so everything will be kept up-to-date.
|
||
; <H9> 3/16/92 SWC Modified CPUSpeedMSC to support 16, 20, 25, and 33MHz machines.
|
||
; We're only planning to do 25 and 33, but if marketing wants to
|
||
; do the slower ones, at least the support's done for free.
|
||
; <H8> 3/13/92 SWC Fixed a couple of bugs in CPUSpeedMSC.
|
||
; <H7> 3/11/92 SWC Added an entry to the info tables for the address of the power
|
||
; cycling register. Added a routine entry for a clamshell switch
|
||
; monitoring VBL task. Added an IdleMind routine for DBLite to
|
||
; check if the clamshell has been closed.
|
||
; <H6> 3/6/92 SWC Added a routine to reset the internal SCC's channel B on wakeup
|
||
; since it seems to be getting into a weird state (this may go
|
||
; away later once I figure out what's happening, but it will help
|
||
; for now).
|
||
; <H5> 2/21/92 HJR Added Power cycling to the PrimsRec. Added WakeLvl hysteresis to
|
||
; the PrimInfos.
|
||
; <H4> 2/7/92 SWC Added default hysteresis and low/dead battery warning levels to
|
||
; the primitives info tables.
|
||
; <H3> 2/7/92 SWC Added support for determining battery level so we can handle
|
||
; different hardware implementations. Made the table offsets in
|
||
; PmgrPrimLookup self-relative.
|
||
; <H2> 2/4/92 SWC Added support for sleep and wakeup tables. Fixed a bug in
|
||
; CPUSpeedMSC. Added assembly conditionals (by decoder) just to be
|
||
; thorough. Cleaned up the code here and there. Added padding to
|
||
; make the code fixed-size.
|
||
; <H1> 2/3/92 HJR first checked in
|
||
|
||
BLANKS ON
|
||
STRING ASIS
|
||
|
||
PRINT OFF
|
||
LOAD 'StandardEqu.d'
|
||
INCLUDE 'HardwarePrivateEqu.a'
|
||
INCLUDE 'SoundPrivate.a'
|
||
INCLUDE 'UniversalEqu.a'
|
||
INCLUDE 'PowerPrivEqu.a'
|
||
INCLUDE 'PowerMgrDispatchEqu.a'
|
||
INCLUDE 'MMUEqu.a'
|
||
INCLUDE 'IOPrimitiveEqu.a'
|
||
INCLUDE 'DockingEqu.a'
|
||
INCLUDE 'ShutDown.a'
|
||
INCLUDE 'ROMEqu.a'
|
||
INCLUDE 'Video.a'
|
||
INCLUDE 'Notification.a'
|
||
INCLUDE 'GestaltEqu.a'
|
||
INCLUDE 'Processes.a'
|
||
INCLUDE 'SlotMgrEqu.a'
|
||
INCLUDE 'DepVideoEqu.a'
|
||
INCLUDE 'Palettes.a'
|
||
INCLUDE 'LayerEqu.a'
|
||
INCLUDE 'ENETEqu.a'
|
||
PRINT ON
|
||
|
||
MACHINE MC68030
|
||
MC68881
|
||
|
||
|
||
PowerMgrPrimitives PROC EXPORT
|
||
|
||
IF hasPwrControls THEN
|
||
|
||
IMPORT AbsoluteBattery ; PowerMgr.a
|
||
IMPORT BatWatch ; PowerMgr.a
|
||
IMPORT DockingSleep ; DockingMgr.a
|
||
IMPORT DockingWakeup ; DockingMgr.a
|
||
IMPORT GracefulShutdown ; PowerMgr.a
|
||
IMPORT PMGRrecv ; PowerMgr.a
|
||
IMPORT PMGRsend ; PowerMgr.a
|
||
IMPORT PrivateFeatures ; PowerMgr.a
|
||
IMPORT SetSupervisorMode ; PowerMgr.a
|
||
|
||
EXPORT GetLevel
|
||
|
||
WITH PmgrRec,PowerDispRec,PmgrPramRec
|
||
WITH PmgrPrimitivesRec,PmgrRoutineRec,PrimInfoTbleRec,IdleMindTblRec
|
||
WITH pmCommandRec,nmRec,PmgrPramRec,ProcessInfoRec
|
||
WITH DecoderInfo,DecoderKinds,ProductInfo,VideoInfo
|
||
|
||
|
||
IF hasJAWS THEN
|
||
;••••••••••••••••••••••••••••••••••••••••• JAWS ••••••••••••••••••••••••••••••••••••••••••
|
||
|
||
EXPORT JawsPmgrPrims
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypeTable ; flags
|
||
DC.L (JawsPmgrPrimsEnd-JawsPmgrPrims) ; size of table
|
||
JawsPmgrPrims ; Table of Primitive Tables
|
||
DC.L JawsRoutines-JawsPmgrPrims ; offset to table of Jaws routines
|
||
DC.L JawsPrimInfo-JawsPmgrPrims ; offset to table decoder-specific constants
|
||
DC.L JawsIdleMindTable-JawsPmgrPrims ; offset to table of Idlemind routines
|
||
DC.L JawsSleepTable-JawsPmgrPrims ; offset to table of sleep routines
|
||
DC.L JawsWakeTable-JawsPmgrPrims ; offset to table of wakeup routines
|
||
DC.L 0 ; no PMgrOp exception table
|
||
DC.L ModemTable-JawsPmgrPrims ; offset to table modem routines <H31>
|
||
DC.L PwrDispatchVects-JawsPmgrPrims ; offset to power dispatch table
|
||
DC.L 0 ; no PMgr hook table
|
||
DC.L CommsPowerTable-JawsPmgrPrims ; offset to table of comms power routines <K12>
|
||
DC.L PMgrOpTbl-JawsPmgrPrims ; offset to routine for PmgrOp
|
||
DC.L 0 ; offset to backlight tables
|
||
JawsPmgrPrimsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (JawsRoutinesEnd-JawsRoutines) ; size of table
|
||
JawsRoutines ; machine-specific routines
|
||
DC.L PowerCycle030-JawsRoutines ; offset to routine for power cycling <H5>
|
||
DC.L Restore030-JawsRoutines ; offset to routine for power cycling restore <H5>
|
||
DC.L BatWatch-JawsRoutines ; offset to VBL task to check the battery level <H19>
|
||
DC.L GetLevel-JawsRoutines ; offset to routine for determining battery level
|
||
DC.L LeadScaledBatteryInfo-JawsRoutines ; offset to routine to return scaled battery level<H15>
|
||
DC.L 0 ; no enviromental int
|
||
DC.L 0 ; no clamshell
|
||
DC.L CPUSpeedJaws-JawsRoutines ; offset to routine for determining CPU speed
|
||
DC.L SndWatch-JawsRoutines ; offset to VBL task to check for sound usage <H19>
|
||
DC.L RedrawScrn-JawsRoutines ; offset to routine for refreshing the screen <H17>
|
||
DC.L LeadAbsoluteBatteryVoltage-JawsRoutines; routine to return absolute battery level<H54>
|
||
DC.L 0 ; no routine to return info about battery times
|
||
DC.L 0 ; dynamic CPU speed change is not supported <H56>
|
||
JawsRoutinesEnd
|
||
|
||
DC.L PrimsTypeInfo ; flags
|
||
DC.L (JawsPrimInfoEnd-JawsPrimInfo) ; size of table
|
||
JawsPrimInfo ; machine-specific constants:
|
||
DC.B $70 ; PRAM base address
|
||
DC.B DefHysteresis ; default hysteresis
|
||
DC.B PMGRWARNLEVEL-STDOFFSET ; default low battery warning level <H5>
|
||
DC.B PMGRCUTOFF-STDOFFSET ; default dead battery warning level <H5>
|
||
DC.B PGMRWAKELEVEL-STDOFFSET ; hysteresis setting for pmgr wake level <H5>
|
||
DC.B (1-1) ; display shorted battery at second interrupt <H33><H7>
|
||
DC.B 0 ; no external video correction needed <H7><H33>
|
||
DC.B 0 ; no charger features
|
||
DC.L $50FA0000 ; address of power cycling register <H7>
|
||
DC.L 0 |\ ; bitmap of public Power Manager features <H52>
|
||
(0<<hasWakeupTimer) |\
|
||
(1<<hasSharedModemPort) |\
|
||
(1<<hasProcessorCycling) |\
|
||
(0<<mustProcessorCycle) |\
|
||
(1<<hasReducedSpeed) |\
|
||
(0<<dynamicSpeedChange) |\
|
||
(0<<hasSCSIDiskMode)
|
||
DC.L 0 |\ ; bitmap of private Power Manager features <H53>
|
||
(0<<hasExtdBattInfo) |\
|
||
(0<<hasBatteryID) |\
|
||
(0<<canSwitchPower)
|
||
DC.W 1 ; number of batteries
|
||
DC.B 0 ; Power manager has a parallel interface
|
||
DC.B 0 ; padding for now
|
||
DC.L 0 ; no extended charge time
|
||
DC.B 0 ; value for power cycling register <K22>
|
||
DC.B 0 ; value for sleep register <K22>
|
||
DC.B 0 ; padding for now
|
||
DC.B 0 ; padding for now
|
||
JawsPrimInfoEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (JawsIdleMindTableEnd-JawsIdleMindTable); size of table
|
||
JawsIdleMindTable ; machine specific IdleMind Routines
|
||
DC.L CheckCountDownTimer-JawsIdleMindTable ; offset to count down timer
|
||
DC.L RunIdleRoutinesProc-JawsIdleMindTable ; offset to run idle procs
|
||
DC.L ChkSleepTimeOut-JawsIdleMindTable ; offset to sleep time out
|
||
DC.L ChkIdle-JawsIdleMindTable ; offset to check idle
|
||
DC.L CalcProgressive-JawsIdleMindTable ; offset to calc progressive
|
||
DC.L GoPowerCycle-JawsIdleMindTable ; offset to go power cycle
|
||
JawsIdleMindTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (JawsSleepTableEnd-JawsSleepTable) ; size of table
|
||
JawsSleepTable ; list of routines to execute when going to sleep:
|
||
DC.L SleepHD-JawsSleepTable ; sleep the hard drive if currently running <K22>
|
||
DC.L SaveVIA1-JawsSleepTable ; save VIA1 registers
|
||
DC.L SaveASCBatman-JawsSleepTable ; save ASC/Batman registers
|
||
DC.L SaveFPU-JawsSleepTable ; save FPU registers
|
||
DC.L SaveVIA2-JawsSleepTable ; save VIA2 registers
|
||
DC.L SendSleep-JawsSleepTable ; send a sleep command
|
||
DC.L SaveSlp030-JawsSleepTable ; save MMU registers
|
||
DC.L SaveSleepInfo-JawsSleepTable ; save sleep info in video RAM
|
||
DC.L 0 ; (end of table)
|
||
JawsSleepTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (JawsWakeTableEnd-JawsWakeTable) ; size of table
|
||
JawsWakeTable ; list of routines to execute when waking up:
|
||
DC.L RestoreSlp030-JawsWakeTable ; restore MMU, SPs, cache registers
|
||
DC.L RestoreVIA2-JawsWakeTable ; restore VIA2 registers
|
||
DC.L RestoreFPU-JawsWakeTable ; restore FPU registers
|
||
DC.L RestoreASCBatman-JawsWakeTable ; restore ASC and Batman registers
|
||
DC.L RestoreVIA1-JawsWakeTable ; restore VIA1 registers
|
||
DC.L WakeClrInts-JawsWakeTable ; clear any pending PmgrInterrupts
|
||
DC.L WakeSoundSetJaws-JawsWakeTable ; set state for sound out of sleep
|
||
DC.L 0 ; (end of table)
|
||
JawsWakeTableEnd
|
||
|
||
|
||
ALIGN 4
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: CPUSpeedJaws
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: D0 - [maximum CPU speed][current CPU speed]
|
||
;
|
||
; Trashes: A0
|
||
;
|
||
; Function: returns the maximum and current (econo-mode or full) CPU speeds for
|
||
; JAWS-based machines
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
CPUSpeedJaws
|
||
MOVEA.L UnivInfoPtr,A0 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(A0),A0 ; then to the DecoderInfo table,
|
||
MOVEA.L JawsAddr(A0),A0 ; then to the JAWS base address,
|
||
ADDA.L #JAWSGetCPUClock,A0 ; and finally to the CPU clock register
|
||
BTST #0,(A0) ; are we a 25MHz or 16MHz machine?
|
||
ADDA.L #JAWSEconoMode-JAWSGetCPUClock,A0 ; (point to the econo-mode register)
|
||
BEQ.S @16MHz ; -> 16MHz
|
||
MOVE.L #(CPUSpeed25MHz<<16)|\ ; assume we're running full-speed at 25MHz
|
||
(CPUSpeed25MHz<<0),D0
|
||
BTST #1,(A0) ; are we in econo-mode?
|
||
BEQ.S @NoEcono25 ; -> nope, we're done
|
||
MOVE.W #CPUSpeed16MHz,D0 ; yes, we're currently running at 16MHz
|
||
@NoEcono25 RTS
|
||
|
||
@16MHz MOVE.L #(CPUSpeed16MHz<<16)|\ ; assume we're running full-speed at 16MHz
|
||
(CPUSpeed16MHz<<0),D0
|
||
BTST #1,(A0) ; are we in econo-mode?
|
||
BEQ.S @NoEcono16 ; -> nope, we're done
|
||
MOVE.W #CPUSpeed8MHz,D0 ; yes, we're currently running at 8MHz
|
||
@NoEcono16 RTS
|
||
|
||
ENDIF
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine for setting sound (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
WakeSoundSetNiagra
|
||
WakeSoundSetJaws
|
||
MOVEM.L A0-A1,-(SP) ; save special registers
|
||
SUBQ.W #4,SP ; Create stack frame
|
||
MOVE.L SP,A0
|
||
MOVE.B #sndClrLtch,(A0) ; Clear the Sound latch
|
||
MOVEQ #1,D1 ; One long to send
|
||
MOVE.W #SoundSet,D0 ; PMGR command, Set Sound Control
|
||
MOVE.L A2,-(SP)
|
||
BigJSR PMGRsend,A2 ; have the PMGR clear the sound latch
|
||
MOVE.L (SP)+,A2
|
||
ADDQ.W #4,SP ; Remove stack frame
|
||
|
||
With ExpandmemRec,SoundIOHeader
|
||
MOVEA.L ([Expandmem],\
|
||
emSndPrimitives),A0 ; Get pointer to Expandmem
|
||
MOVE.B DFAClast(A0),D0 ; get last byte sent to DFAC
|
||
jsrTBL sndDFACSend,A0 ; send byte to DFAC
|
||
Endwith
|
||
MOVEM.L (SP)+,A0-A1 ; restore special registers
|
||
JMP (A1) ; go home
|
||
|
||
IF hasMSC THEN
|
||
;••••••••••••••••••••••••••••••••••••••••• MBT •••••••••••••••••••••••••••••••••••••••••••
|
||
|
||
EXPORT MBTPmgrPrims
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypeTable ; flags
|
||
DC.L (MBTPmgrPrimsEnd-MBTPmgrPrims) ; size of table
|
||
MBTPmgrPrims ; Table of Primitives tables
|
||
DC.L MBTRoutines-MBTPmgrPrims ; offset to table of MSC routines
|
||
DC.L MBTPrimInfo-MBTPmgrPrims ; offset to decoder-specific constants
|
||
DC.L MBTIdleMindTable-MBTPmgrPrims ; offset to table of Idlemind routines <H7>
|
||
DC.L MBTSleepTable-MBTPmgrPrims ; offset to table of sleep routines
|
||
DC.L MBTWakeTable-MBTPmgrPrims ; offset to table of wakeup routines
|
||
DC.L MBTModemTable-MBTPmgrPrims ; offset to table of modem routines <H31>
|
||
DC.L MBTPMgrOpExceptions-MBTPmgrPrims ; offset to PMgrOp exception table
|
||
DC.L PwrDispatchVects-MBTPmgrPrims ; offset to table of PwrDispatchVects
|
||
DC.L PMgrHookVects-MBTPmgrPrims ; offset to table of PmgrMgr Hooks
|
||
DC.L 0 ; no comms power routines <K12>
|
||
DC.L PMgrOpTbl-MBTPmgrPrims ; offset to routine for PmgrOp
|
||
DC.L 0 ; offset to backlight tables
|
||
MBTPmgrPrimsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MBTRoutinesEnd-MBTRoutines) ; size of table
|
||
MBTRoutines ; machine-specific routines
|
||
DC.L PowerCycle040-MBTRoutines ; offset to routine for power cycling <H5>
|
||
DC.L Restore040-MBTRoutines ; offset to routine for power cycling restore <H5>
|
||
DC.L BatWatch-MBTRoutines ; offset to VBL task to check the battery level <H19>
|
||
DC.L GetExtLevel-MBTRoutines ; offset to routine for determining battery level
|
||
DC.L MultiScaledBatteryInfo-MBTRoutines ; offset to routine to return scaled battery level <H15>
|
||
DC.L 0 ; no environment interrupts
|
||
DC.L ClamshellVBL-MBTRoutines ; offset to VBL task to check for clamshell closed <H7>
|
||
DC.L CPUSpeedMSC-MBTRoutines ; offset to routine for determining CPU speed
|
||
DC.L SndWatchMSC-MBTRoutines ; offset to VBL task to check for sound usage <H19>
|
||
DC.L RedrawScrn-MBTRoutines ; offset to routine for refreshing the screen <H18>
|
||
DC.L PGEAbsoluteBatteryVoltage-MBTRoutines ; routine to return absolute battery level <H54>
|
||
DC.L 0 ; no routine to return info about battery times
|
||
DC.L 0 ; dynamic CPU speed change is not supported
|
||
MBTRoutinesEnd
|
||
|
||
DC.L PrimsTypeInfo ; flags
|
||
DC.L (MBTPrimInfoEnd-MBTPrimInfo) ; size of table
|
||
MBTPrimInfo ; machine-specific constants:
|
||
DC.B $46 ; PRAM base address
|
||
DC.B DefHysteresis ; default hysteresis
|
||
DC.B 0 ; default low battery warning level (none) <H12>
|
||
DC.B 0 ; default dead battery warning level (none) <H12>
|
||
DC.B 0 ; hysteresis setting for wake level (none) <H12>
|
||
DC.B 0 ; shorted battery at first interrupt (none) <H33> <H7>
|
||
DC.B 0 ; no external video correction needed <H7>
|
||
DC.B 0 |\ ; bitmap of charger attributes
|
||
(1<<hasSleepLED) |\
|
||
(1<<hasForcedDischarge) |\
|
||
(0<<hasDBCharger) |\
|
||
(1<<hasEscherCharger)
|
||
DC.L $50FA0000 ; address of power cycling register <H7>
|
||
DC.L 0 |\ ; bitmap of Power Manager features <H52>
|
||
(1<<hasWakeupTimer) |\
|
||
(0<<hasSharedModemPort) |\
|
||
(1<<hasProcessorCycling) |\
|
||
(0<<mustProcessorCycle) |\
|
||
(0<<hasReducedSpeed) |\
|
||
(0<<dynamicSpeedChange) |\
|
||
(1<<hasSCSIDiskMode)
|
||
DC.L 0 |\ ; bitmap of private Power Manager features <H53>
|
||
(1<<hasExtdBattInfo) |\
|
||
(1<<hasBatteryID) |\
|
||
(0<<canSwitchPower)
|
||
DC.W 1 ; number of batteries
|
||
DC.B 2 ; Power Manager Serial Interface <H7>
|
||
DC.B 0 ; padding for now
|
||
DC.L 0 ; no extended charging
|
||
DC.B $5A ; value for power cycling register <K22>
|
||
DC.B 0 ; value for sleep register <K22>
|
||
DC.B 0 ; padding for now
|
||
DC.B 0 ; padding for now
|
||
MBTPrimInfoEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MBTIdleMindTableEnd-MBTIdleMindTable); size of table
|
||
MBTIdleMindTable ; machine specific IdleMind Routines
|
||
DC.L CheckCountDownTimer-MBTIdleMindTable; offset to count down timer
|
||
DC.L CheckClamshell-MBTIdleMindTable ; offset to clam shell <H20>
|
||
DC.L ChkSleepTimeOut-MBTIdleMindTable ; offset to sleep time out
|
||
DC.L ChkIdle-MBTIdleMindTable ; offset to check idle
|
||
DC.L CalcProgressive-MBTIdleMindTable ; offset to calc progressive
|
||
DC.L GoPowerCycle-MBTIdleMindTable ; offset to go power cycle
|
||
MBTIdleMindTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MBTSleepTableEnd-MBTSleepTable) ; size of table
|
||
MBTSleepTable ; list of routines to execute when going to sleep:
|
||
DC.L SleepHD-MBTSleepTable ; sleep the hard drive if currently running <K22>
|
||
DC.L DockingSleep-MBTSleepTable ; save state of currently connected bar <H10>
|
||
DC.L SaveVIA1-MBTSleepTable ; save VIA1 registers
|
||
DC.L SaveASCBatman-MBTSleepTable ; save ASC/Batman registers
|
||
DC.L SaveFPU-MBTSleepTable ; save FPU registers
|
||
DC.L SaveLCD-MBTSleepTable ; save GSC (built-in LCD video) registers
|
||
DC.L SaveMSC-MBTSleepTable ; save MSC registers
|
||
DC.L SendSleepLP-MBTSleepTable ; send a sleep command <H42>
|
||
DC.L SaveSlp040-MBTSleepTable ; save MMU registers
|
||
DC.L SaveSleepInfo-MBTSleepTable ; save sleep info in Power Manager globals
|
||
DC.L MSCKillPower-MBTSleepTable ; have MSC pull the plug as well
|
||
DC.L 0 ; (end of table)
|
||
MBTSleepTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MBTWakeTableEnd-MBTWakeTable) ; size of table
|
||
MBTWakeTable ; list of routines to execute when waking up:
|
||
DC.L RestoreSlp040-MBTWakeTable ; restore MMU, SPs, cache registers
|
||
DC.L RestoreMSC-MBTWakeTable ; restore volatile MSC registers
|
||
DC.L RestoreLCD-MBTWakeTable ; restore GSC (built-in LCD video) registers
|
||
DC.L RestoreFPU-MBTWakeTable ; restore FPU registers
|
||
DC.L RestoreASCBatman-MBTWakeTable ; restore ASC and Batman registers
|
||
DC.L RestoreVIA1-MBTWakeTable ; restore VIA1 registers
|
||
DC.L MSCInitSCC-MBTWakeTable ; reset channel B on internal SCC <H6>
|
||
DC.L DockingWakeup-MBTWakeTable ; restore state of currently connected bar <H10>
|
||
DC.L WakeClrInts-MBTWakeTable ; clear any pending PmgrInterrupts
|
||
DC.L WakeSoundSet-MBTWakeTable ; set state for sound out of sleep
|
||
DC.L 0 ; (end of table)
|
||
MBTWakeTableEnd
|
||
|
||
DC.L PrimsTypePMgrEx ; flags
|
||
DC.L (MBTPMgrOpExceptionsEnd-MBTPMgrOpExceptions) ; size of table
|
||
MBTPMgrOpExceptions ; PMgrOp exceptions:
|
||
DC.B $FF,powerCntl ; $10 - power control
|
||
DC.L MSCPowerControl-*
|
||
DC.B $FF,powerRead ; $18 - power status
|
||
DC.L MSCPowerStatus-*
|
||
DC.B $FF,$1F ; $1F - fake power status (for MSC/PG&E)
|
||
DC.L MSCFakePowerStatus-*
|
||
DC.B $FE,batteryRead ; $68, $69 - read battery status
|
||
DC.L MSCReadBattery-*
|
||
DC.B $FF,soundSet ; $90 - clear sound latch, turn sound power on/off
|
||
DC.L MSCSetSound-*
|
||
DC.B $FF,soundRead ; $98 - return sound latch, sound power status
|
||
DC.L MSCReadSound-*
|
||
DC.W 0 ; (end of table)
|
||
MBTPMgrOpExceptionsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags <K10>
|
||
DC.L (MBTModemTableEnd-MBTModemTable) ; size of table
|
||
MBTModemTable
|
||
DC.L 0 ; offset to routine to turn on modem
|
||
DC.L 0 ; offset to routine to turn off modem
|
||
DC.L DBLiteModemType-MBTModemTable ; offset to routine to get modem type
|
||
MBTModemTableEnd
|
||
|
||
ALIGN 4
|
||
|
||
;••••••••••••••••••••••••••••••••••••••••• MSC2 •••••••••••••••••••••••••••••••••••••••••••
|
||
|
||
EXPORT MSC2PmgrPrims
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypeTable ; flags
|
||
DC.L (MSC2PmgrPrimsEnd-MSC2PmgrPrims) ; size of table
|
||
MSC2PmgrPrims ; Table of Primitives tables
|
||
DC.L MSC2Routines-MSC2PmgrPrims ; offset to table of MSC routines
|
||
DC.L MSC2PrimInfo-MSC2PmgrPrims ; offset to decoder-specific constants
|
||
DC.L MSC2IdleMindTable-MSC2PmgrPrims ; offset to table of Idlemind routines <H7>
|
||
DC.L MSC2SleepTable-MSC2PmgrPrims ; offset to table of sleep routines
|
||
DC.L MSC2WakeTable-MSC2PmgrPrims ; offset to table of wakeup routines
|
||
DC.L MSC2ModemTable-MSC2PmgrPrims ; offset to table of modem routines <H31>
|
||
DC.L MSC2PMgrOpExceptions-MSC2PmgrPrims ; offset to PMgrOp exception table
|
||
DC.L PwrDispatchVects-MSC2PmgrPrims ; offset to table of PwrDispatchVects
|
||
DC.L PMgrHookVects-MSC2PmgrPrims ; offset to table of PmgrMgr Hooks
|
||
DC.L 0 ; no comms power routines <K12>
|
||
DC.L PMgrOpTbl-MSC2PmgrPrims ; offset to routine for PmgrOp
|
||
DC.L 0 ; offset to backlight tables
|
||
MSC2PmgrPrimsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSC2RoutinesEnd-MSC2Routines) ; size of table
|
||
MSC2Routines ; machine-specific routines
|
||
DC.L PowerCycle040-MSC2Routines ; offset to routine for power cycling <H5>
|
||
DC.L Restore040-MSC2Routines ; offset to routine for power cycling restore <H5>
|
||
DC.L BatWatch-MSC2Routines ; offset to VBL task to check the battery level <H19>
|
||
DC.L GetExtLevel-MSC2Routines ; offset to routine for determining battery level
|
||
DC.L MultiScaledBatteryInfo-MSC2Routines ; offset to routine to return scaled battery level <H15>
|
||
DC.L 0 ; no environment interrupts
|
||
DC.L ClamshellVBL-MSC2Routines ; offset to VBL task to check for clamshell closed <H7>
|
||
DC.L CPUSpeedMSC-MSC2Routines ; offset to routine for determining CPU speed
|
||
DC.L SndWatchMSC-MSC2Routines ; offset to VBL task to check for sound usage <H19>
|
||
DC.L RedrawScrn-MSC2Routines ; offset to routine for refreshing the screen <H18>
|
||
DC.L PGEAbsoluteBatteryVoltage-MSC2Routines ; routine to return absolute battery level <H54>
|
||
DC.L 0 ; no routine to return info about battery times
|
||
DC.L 0 ; dynamic CPU speed change is not supported
|
||
MSC2RoutinesEnd
|
||
|
||
DC.L PrimsTypeInfo ; flags
|
||
DC.L (MSC2PrimInfoEnd-MSC2PrimInfo) ; size of table
|
||
MSC2PrimInfo ; machine-specific constants:
|
||
DC.B $46 ; PRAM base address
|
||
DC.B DefHysteresis ; default hysteresis
|
||
DC.B 0 ; default low battery warning level (none) <H12>
|
||
DC.B 0 ; default dead battery warning level (none) <H12>
|
||
DC.B 0 ; hysteresis setting for wake level (none) <H12>
|
||
DC.B 0 ; shorted battery at first interrupt (none) <H33> <H7>
|
||
DC.B 0 ; no external video correction needed <H7>
|
||
DC.B 0 |\ ; bitmap of charger attributes
|
||
(1<<hasSleepLED) |\
|
||
(1<<hasForcedDischarge) |\
|
||
(0<<hasDBCharger) |\
|
||
(1<<hasEscherCharger)
|
||
DC.L $50FA0000 ; address of power cycling register <H7>
|
||
DC.L 0 |\ ; bitmap of Power Manager features <H52>
|
||
(1<<hasWakeupTimer) |\
|
||
(0<<hasSharedModemPort) |\
|
||
(1<<hasProcessorCycling) |\
|
||
(0<<mustProcessorCycle) |\
|
||
(0<<hasReducedSpeed) |\
|
||
(0<<dynamicSpeedChange) |\
|
||
(1<<hasSCSIDiskMode)
|
||
DC.L 0 |\ ; bitmap of private Power Manager features <H53>
|
||
(1<<hasExtdBattInfo) |\
|
||
(1<<hasBatteryID) |\
|
||
(0<<canSwitchPower)
|
||
DC.W 1 ; number of batteries
|
||
DC.B 2 ; Power Manager Serial Interface <H7>
|
||
DC.B 0 ; padding for now
|
||
DC.L 0 ; no extended charging
|
||
DC.B $5A ; value for power cycling register <K22>
|
||
DC.B 0 ; value for sleep register <K22>
|
||
DC.B 0 ; padding for now
|
||
DC.B 0 ; padding for now
|
||
MSC2PrimInfoEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSC2IdleMindTableEnd-MSC2IdleMindTable); size of table
|
||
MSC2IdleMindTable ; machine specific IdleMind Routines
|
||
DC.L CheckCountDownTimer-MSC2IdleMindTable; offset to count down timer
|
||
DC.L CheckClamshell-MSC2IdleMindTable ; offset to clam shell <H20>
|
||
DC.L ChkSleepTimeOut-MSC2IdleMindTable ; offset to sleep time out
|
||
DC.L ChkIdle-MSC2IdleMindTable ; offset to check idle
|
||
DC.L CalcProgressive-MSC2IdleMindTable ; offset to calc progressive
|
||
DC.L GoPowerCycle-MSC2IdleMindTable ; offset to go power cycle
|
||
MSC2IdleMindTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSC2SleepTableEnd-MSC2SleepTable) ; size of table
|
||
MSC2SleepTable ; list of routines to execute when going to sleep:
|
||
DC.L SleepHD-MSC2SleepTable ; sleep the hard drive if currently running <K22>
|
||
DC.L DockingSleep-MSC2SleepTable ; save state of currently connected bar <H10>
|
||
DC.L SaveVIA1-MSC2SleepTable ; save VIA1 registers
|
||
DC.L SaveASCBatman-MSC2SleepTable ; save ASC/Batman registers
|
||
DC.L SaveFPU-MSC2SleepTable ; save FPU registers
|
||
DC.L SaveLCD-MSC2SleepTable ; save GSC (built-in LCD video) registers
|
||
DC.L SaveMSC-MSC2SleepTable ; save MSC registers
|
||
DC.L SendSleepLP-MSC2SleepTable ; send a sleep command <H42>
|
||
DC.L SaveSlp040-MSC2SleepTable ; save MMU registers
|
||
DC.L SaveSleepInfo-MSC2SleepTable ; save sleep info in Power Manager globals
|
||
DC.L MSCKillPower-MSC2SleepTable ; have MSC pull the plug as well
|
||
DC.L 0 ; (end of table)
|
||
MSC2SleepTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSC2WakeTableEnd-MSC2WakeTable) ; size of table
|
||
MSC2WakeTable ; list of routines to execute when waking up:
|
||
DC.L RestoreSlp040-MSC2WakeTable ; restore MMU, SPs, cache registers
|
||
DC.L RestoreMSC-MSC2WakeTable ; restore volatile MSC registers
|
||
DC.L RestoreLCD-MSC2WakeTable ; restore GSC (built-in LCD video) registers
|
||
DC.L RestoreFPU-MSC2WakeTable ; restore FPU registers
|
||
DC.L RestoreASCBatman-MSC2WakeTable ; restore ASC and Batman registers
|
||
DC.L RestoreVIA1-MSC2WakeTable ; restore VIA1 registers
|
||
DC.L MSCInitSCC-MSC2WakeTable ; reset channel B on internal SCC <H6>
|
||
DC.L DockingWakeup-MSC2WakeTable ; restore state of currently connected bar <H10>
|
||
DC.L WakeClrInts-MSC2WakeTable ; clear any pending PmgrInterrupts
|
||
DC.L WakeSoundSet-MSC2WakeTable ; set state for sound out of sleep
|
||
DC.L 0 ; (end of table)
|
||
MSC2WakeTableEnd
|
||
|
||
DC.L PrimsTypePMgrEx ; flags
|
||
DC.L (MSC2PMgrOpExceptionsEnd-MSC2PMgrOpExceptions) ; size of table
|
||
MSC2PMgrOpExceptions ; PMgrOp exceptions:
|
||
DC.B $FF,powerCntl ; $10 - power control
|
||
DC.L MSCPowerControl-*
|
||
DC.B $FF,powerRead ; $18 - power status
|
||
DC.L MSCPowerStatus-*
|
||
DC.B $FF,$1F ; $1F - fake power status (for MSC/PG&E)
|
||
DC.L MSCFakePowerStatus-*
|
||
DC.B $FE,batteryRead ; $68, $69 - read battery status
|
||
DC.L MSCReadBattery-*
|
||
DC.B $FF,soundSet ; $90 - clear sound latch, turn sound power on/off
|
||
DC.L MSCSetSound-*
|
||
DC.B $FF,soundRead ; $98 - return sound latch, sound power status
|
||
DC.L MSCReadSound-*
|
||
DC.W 0 ; (end of table)
|
||
MSC2PMgrOpExceptionsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags <K10>
|
||
DC.L (MSC2ModemTableEnd-MSC2ModemTable) ; size of table
|
||
MSC2ModemTable
|
||
DC.L 0 ; offset to routine to turn on modem
|
||
DC.L 0 ; offset to routine to turn off modem
|
||
DC.L DBLiteModemType-MSC2ModemTable ; offset to routine to get modem type
|
||
MSC2ModemTableEnd
|
||
|
||
ALIGN 4
|
||
|
||
|
||
;••••••••••••••••••••••••••••••••••••••••• MSC •••••••••••••••••••••••••••••••••••••••••••
|
||
|
||
EXPORT MSCPmgrPrims
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypeTable ; flags
|
||
DC.L (MSCPmgrPrimsEnd-MSCPmgrPrims) ; size of table
|
||
MSCPmgrPrims ; Table of Primitives tables
|
||
DC.L MSCRoutines-MSCPmgrPrims ; offset to table of MSC routines
|
||
DC.L MSCPrimInfo-MSCPmgrPrims ; offset to decoder-specific constants
|
||
DC.L MSCIdleMindTable-MSCPmgrPrims ; offset to table of Idlemind routines <H7>
|
||
DC.L MSCSleepTable-MSCPmgrPrims ; offset to table of sleep routines
|
||
DC.L MSCWakeTable-MSCPmgrPrims ; offset to table of wakeup routines
|
||
DC.L MSCModemTable-MSCPmgrPrims ; offset to table of modem routines <H31>
|
||
DC.L MSCPMgrOpExceptions-MSCPmgrPrims ; offset to PMgrOp exception table
|
||
DC.L PwrDispatchVects-MSCPmgrPrims ; offset to table of PwrDispatchVects
|
||
DC.L PMgrHookVects-MSCPmgrPrims ; offset to table of PmgrMgr Hooks
|
||
DC.L 0 ; no comms power routines <K12>
|
||
DC.L PMgrOpTbl-MSCPmgrPrims ; offset to routine for PmgrOp
|
||
DC.L 0 ; offset to backlight tables
|
||
MSCPmgrPrimsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSCRoutinesEnd-MSCRoutines) ; size of table
|
||
MSCRoutines ; machine-specific routines
|
||
DC.L PowerCycle030-MSCRoutines ; offset to routine for power cycling <H5>
|
||
DC.L Restore030-MSCRoutines ; offset to routine for power cycling restore <H5>
|
||
DC.L BatWatch-MSCRoutines ; offset to VBL task to check the battery level <H19>
|
||
DC.L GetExtLevel-MSCRoutines ; offset to routine for determining battery level
|
||
DC.L MultiScaledBatteryInfo-MSCRoutines ; offset to routine to return scaled battery level <H15>
|
||
DC.L 0 ; no environment interrupts
|
||
DC.L ClamshellVBL-MSCRoutines ; offset to VBL task to check for clamshell closed <H7>
|
||
DC.L CPUSpeedMSC-MSCRoutines ; offset to routine for determining CPU speed
|
||
DC.L SndWatchMSC-MSCRoutines ; offset to VBL task to check for sound usage <H19>
|
||
DC.L RedrawScrn-MSCRoutines ; offset to routine for refreshing the screen <H18>
|
||
DC.L PGEAbsoluteBatteryVoltage-MSCPmgrPrims ; routine to return absolute battery level <H54>
|
||
DC.L 0 ; no routine to return info about battery times
|
||
DC.L ChangeCPUSpeedMSC-MSCPmgrPrims ; routine to do a dynamic CPU speed change <H56>
|
||
MSCRoutinesEnd
|
||
|
||
DC.L PrimsTypeInfo ; flags
|
||
DC.L (MSCPrimInfoEnd-MSCPrimInfo) ; size of table
|
||
MSCPrimInfo ; machine-specific constants:
|
||
DC.B $46 ; PRAM base address
|
||
DC.B DefHysteresis ; default hysteresis
|
||
DC.B 0 ; default low battery warning level (none) <H12>
|
||
DC.B 0 ; default dead battery warning level (none) <H12>
|
||
DC.B 0 ; hysteresis setting for wake level (none) <H12>
|
||
DC.B 0 ; shorted battery at first interrupt (none) <H33> <H7>
|
||
DC.B 0 ; no external video correction needed <H7>
|
||
DC.B 0 ; no charger features
|
||
DC.L $50FA0000 ; address of power cycling register <H7>
|
||
DC.L 0 |\ ; bitmap of Power Manager features <H52>
|
||
(1<<hasWakeupTimer) |\
|
||
(0<<hasSharedModemPort) |\
|
||
(1<<hasProcessorCycling) |\
|
||
(0<<mustProcessorCycle) |\
|
||
(1<<hasReducedSpeed) |\
|
||
(1<<dynamicSpeedChange) |\
|
||
(1<<hasSCSIDiskMode)
|
||
DC.L 0 |\ ; bitmap of private Power Manager features <H53>
|
||
(1<<hasExtdBattInfo) |\
|
||
(1<<hasBatteryID) |\
|
||
(0<<canSwitchPower)
|
||
DC.W 1 ; number of batteries
|
||
DC.B 2 ; Power Manager Serial Interface <H7>
|
||
DC.B 0 ; padding for now
|
||
DC.L 0 ; no extended charging
|
||
DC.B $5A ; value for power cycling register <K22>
|
||
DC.B 0 ; value for sleep register <K22>
|
||
DC.B 0 ; padding for now
|
||
DC.B 0 ; padding for now
|
||
MSCPrimInfoEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSCIdleMindTableEnd-MSCIdleMindTable); size of table
|
||
MSCIdleMindTable ; machine specific IdleMind Routines
|
||
DC.L CheckCountDownTimer-MSCIdleMindTable; offset to count down timer
|
||
DC.L CheckClamshell-MSCIdleMindTable ; offset to clam shell <H20>
|
||
DC.L ChkSleepTimeOut-MSCIdleMindTable ; offset to sleep time out
|
||
DC.L ChkIdle-MSCIdleMindTable ; offset to check idle
|
||
DC.L CalcProgressive-MSCIdleMindTable ; offset to calc progressive
|
||
DC.L GoPowerCycle-MSCIdleMindTable ; offset to go power cycle
|
||
MSCIdleMindTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSCSleepTableEnd-MSCSleepTable) ; size of table
|
||
MSCSleepTable ; list of routines to execute when going to sleep:
|
||
DC.L SleepHD-MSCSleepTable ; sleep the hard drive if currently running
|
||
DC.L DockingSleep-MSCSleepTable ; save state of currently connected bar <H10>
|
||
DC.L SaveVIA1-MSCSleepTable ; save VIA1 registers
|
||
DC.L SaveASCBatman-MSCSleepTable ; save ASC/Batman registers
|
||
DC.L SaveFPU-MSCSleepTable ; save FPU registers
|
||
DC.L SaveLCD-MSCSleepTable ; save GSC (built-in LCD video) registers
|
||
DC.L SaveMSC-MSCSleepTable ; save MSC registers
|
||
DC.L SendSleepLP-MSCSleepTable ; send a sleep command <H42>
|
||
DC.L SaveSlp030-MSCSleepTable ; save MMU registers
|
||
DC.L SaveSleepInfo-MSCSleepTable ; save sleep info in Power Manager globals
|
||
DC.L MSCKillPower-MSCSleepTable ; have MSC pull the plug as well
|
||
DC.L 0 ; (end of table)
|
||
MSCSleepTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (MSCWakeTableEnd-MSCWakeTable) ; size of table
|
||
MSCWakeTable ; list of routines to execute when waking up:
|
||
DC.L RestoreSlp030-MSCWakeTable ; restore MMU, SPs, cache registers
|
||
DC.L RestoreMSC-MSCWakeTable ; restore volatile MSC registers
|
||
DC.L RestoreLCD-MSCWakeTable ; restore GSC (built-in LCD video) registers
|
||
DC.L RestoreFPU-MSCWakeTable ; restore FPU registers
|
||
DC.L RestoreASCBatman-MSCWakeTable ; restore ASC and Batman registers
|
||
DC.L RestoreVIA1-MSCWakeTable ; restore VIA1 registers
|
||
DC.L MSCInitSCC-MSCWakeTable ; reset channel B on internal SCC <H6>
|
||
DC.L DockingWakeup-MSCWakeTable ; restore state of currently connected bar <H10>
|
||
DC.L WakeClrInts-MSCWakeTable ; clear any pending PmgrInterrupts
|
||
DC.L WakeSoundSet-MSCWakeTable ; set state for sound out of sleep
|
||
DC.L 0 ; (end of table)
|
||
MSCWakeTableEnd
|
||
|
||
DC.L PrimsTypePMgrEx ; flags
|
||
DC.L (MSCPMgrOpExceptionsEnd-MSCPMgrOpExceptions) ; size of table
|
||
MSCPMgrOpExceptions ; PMgrOp exceptions:
|
||
DC.B $FF,powerCntl ; $10 - power control
|
||
DC.L MSCPowerControl-*
|
||
DC.B $FF,powerRead ; $18 - power status
|
||
DC.L MSCPowerStatus-*
|
||
DC.B $FF,$1F ; $1F - fake power status (for MSC/PG&E)
|
||
DC.L MSCFakePowerStatus-*
|
||
DC.B $FE,batteryRead ; $68, $69 - read battery status
|
||
DC.L MSCReadBattery-*
|
||
DC.B $FF,soundSet ; $90 - clear sound latch, turn sound power on/off
|
||
DC.L MSCSetSound-*
|
||
DC.B $FF,soundRead ; $98 - return sound latch, sound power status
|
||
DC.L MSCReadSound-*
|
||
DC.W 0 ; (end of table)
|
||
MSCPMgrOpExceptionsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags <K10>
|
||
DC.L (MSCModemTableEnd-MSCModemTable) ; size of table
|
||
MSCModemTable
|
||
DC.L 0 ; offset to routine to turn on modem
|
||
DC.L 0 ; offset to routine to turn off modem
|
||
DC.L DBLiteModemType-MSCModemTable ; offset to routine to get modem type
|
||
MSCModemTableEnd
|
||
|
||
ALIGN 4
|
||
|
||
;_______________________________________________________________________________________
|
||
;
|
||
; Routine: MSCReadBattery
|
||
;
|
||
; Inputs: A0 -- pointer to caller's parameter block
|
||
;
|
||
; Outputs: D0 -- result code
|
||
; CCR-- always BEQ
|
||
;
|
||
; Trashes: D1,A0-A1
|
||
;
|
||
; Function: Emulates the read battery status ($68) and instantaneous battery status ($69)
|
||
; calls since they're not supported by PG&E. The contents of the receive buffer
|
||
; are mapped as follows:
|
||
;
|
||
; extended status ($6B) read status ($68 or $69)
|
||
; +0 flags (bits) flags (bits)
|
||
; 7: chargeable battery 7: 0
|
||
; 6: "energy used" count valid 6: 0
|
||
; 5: 0 5: charger state change
|
||
; 4: battery termperature valid 4: low battery
|
||
; 3: dead battery 3: dead battery (always 0)
|
||
; 2: battery connected 2: hi-charge counter overflow
|
||
; 1: hi-charge enabled 1: hi-charge enabled
|
||
; 0: charger installed 0: charger installed
|
||
; +1 voltage (H) 0-511 -> 7-21 volts power
|
||
; +2 voltage (L) ambient temperature
|
||
; +3 ambient temperature (°C) -
|
||
; +4 battery temperature (°C) -
|
||
; +5 power usage rate (* 66.9 = mW) -
|
||
; +6 energy used (H) -
|
||
; +7 energy used (L) -
|
||
;_______________________________________________________________________________________
|
||
|
||
MSCReadBattery
|
||
MOVEA.L A0,A1 ; save the parameter block pointer
|
||
SUBQ.W #8,SP ; make space for a buffer
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0 (no bytes sent)
|
||
MOVE.W #readExtBatt,-(SP) ; pmCommand = read extended battery status
|
||
MOVE.L SP,A0
|
||
_PMgrOp ; get extended battery status
|
||
LEA pmRBuffer+4(SP),SP ; (get rid of the parameter block)
|
||
BNE.S @CantRead ; -> error
|
||
|
||
MOVEA.L SP,A0 ; point to our reply buffer
|
||
MOVE.W #3,pmLength(A1) ; stuff the reply count
|
||
MOVEA.L pmRBuffer(A1),A1 ; point to the reply buffer
|
||
MOVEQ #%00001011,D1 ; mask off the relevant flag bits
|
||
AND.B (A0),D1
|
||
MOVE.B D1,(A1)+ ; and stuff them into the buffer
|
||
|
||
MOVEQ #0,D1 ; assume no battery
|
||
BTST #2,(A0)+ ; is there one?
|
||
BEQ.S @NoBattery ; -> no, return zero volts
|
||
MOVE.W (A0),D1 ; get the battery voltage
|
||
LSR.W #1,D1 ; for now, just scale it into 0-255
|
||
@NoBattery MOVE.B D1,(A1)+
|
||
|
||
ADDQ.W #2,A0 ; (skip over voltage)
|
||
MOVE.B (A0)+,(A1)+ ; •••for now, just copy the temperature across
|
||
|
||
@CantRead ADDQ.W #8,SP ; get rid of the buffer
|
||
MOVEQ #0,D1 ; set CCR for BEQ
|
||
RTS
|
||
|
||
|
||
;_______________________________________________________________________________________
|
||
;
|
||
; Routine: MSCPowerControl
|
||
;
|
||
; Inputs: A0 -- pointer to caller's parameter block
|
||
;
|
||
; Outputs: D0 -- result code
|
||
; CCR-- BEQ if the call was emulated, else BNE
|
||
;
|
||
; Trashes: D1-D2, A1
|
||
;
|
||
; Function: Emulates all or part of the powerCntl call ($10) for systems where not all
|
||
; power planes are controlled by the PMGR. The send buffer will contain a
|
||
; byte with the following bits used:
|
||
;
|
||
; bit 0: 1=IWM power
|
||
; 1: 1=SCC power
|
||
; 2: 1=hard disk power
|
||
; 3: 1=internal modem power
|
||
; 4: 1=serial output driver power
|
||
; 5: 1=sound power
|
||
; 6: 1=minus 5 volt power
|
||
; 7: 1=turn on, 0=turn off devices corresponding to 1's in bits 0-6
|
||
;_______________________________________________________________________________________
|
||
|
||
Unimplement EQU $A89F ; _Unimplemented trap
|
||
|
||
MSCPowerControl
|
||
MOVEA.L pmSBuffer(A0),A1 ; point to the transmit buffer
|
||
MOVEQ #0,D1
|
||
MOVE.B (A1),D1 ; get the data byte
|
||
|
||
MOVEM.L D1/A0,-(SP)
|
||
MOVE.W #Unimplement,D0 ; does the _DockingDispatch trap exist?
|
||
_GetTrapAddress ,NEWTOOL
|
||
MOVEA.L A0,A1
|
||
MOVE.W @DockTrap,D0
|
||
_GetTrapAddress ,NEWTOOL
|
||
CMPA.L A0,A1
|
||
BEQ.S @NoDocking ; -> no, just turn internal power planes on/off
|
||
SUBQ.W #4,SP ; result
|
||
PEA dockPowerControl ; docking selector = power control
|
||
MOVE.L D1,-(SP) ; params = which power planes to affect
|
||
@DockTrap _DockingDispatch ; call the handler
|
||
ADDQ.W #4,SP ; toss the result
|
||
@NoDocking MOVEM.L (SP)+,D1/A0
|
||
|
||
MOVEA.L VIA2,A1 ; point to the base of the MSC
|
||
MOVEQ #(1<<pSCC) | (1<<pSerDrvr),D0 ; mask off the SCC power and serial drivers bits
|
||
AND.B D1,D0 ; are either of them set?
|
||
BEQ.S @NoSCC ; -> nope
|
||
EOR.B D0,D1 ; turn them both off
|
||
TST.B D1 ; turn power on or off?
|
||
BMI.S @TurnOnSCC
|
||
BCLR #MSCSCCClk,MSCClkCntl(A1) ; turn off SCC PCLK, RTXC
|
||
BRA.S @NoSCC
|
||
@TurnOnSCC BSET #MSCSCCClk,MSCClkCntl(A1) ; turn on SCC PCLK, RTXC
|
||
|
||
@NoSCC BTST #pHD,D1 ; is hard disk power being turned on/off?
|
||
BEQ.S @NoHD ; -> no
|
||
TST.B D1 ; turn power on or off?
|
||
BMI.S @TurnOnSCSI
|
||
BCLR #MSCSCSIReset,MSCClkCntl(A1) ; drive SCSI chip reset low to stop clocks
|
||
BRA.S @NoHD
|
||
@TurnOnSCSI BSET #MSCSCSIReset,MSCClkCntl(A1) ; drive SCSI chip reset high to start it up
|
||
|
||
@NoHD BCLR #pASC,D1 ; is sound power being turned on/off?
|
||
BEQ.S @NoSound ; -> nope
|
||
TST.B D1 ; turn power on or off?
|
||
BMI.S @TurnOnSnd
|
||
BCLR #MSCSndPower,MSCSndCntl(A1) ; turn off sound power
|
||
BRA.S @NoSound
|
||
@TurnOnSnd BSET #MSCSndPower,MSCSndCntl(A1) ; turn off sound power
|
||
|
||
@NoSound BCLR #pIWM,D1 ; clear the SWIM power bit
|
||
|
||
@NoSWIM MOVEQ #$7F,D0 ; return BNE if any bits are still set
|
||
AND.B D1,D0 ; so we can pass it on to the PMGR
|
||
BNE.S @MorePower ; -> more for the PMGR to do
|
||
CLR.W pmLength(A0) ; fix the returned length since we're done
|
||
@MorePower RTS
|
||
|
||
|
||
;_______________________________________________________________________________________
|
||
;
|
||
; Routine: MSCPowerStatus
|
||
;
|
||
; Inputs: A0 -- pointer to caller's parameter block
|
||
;
|
||
; Outputs: D0 -- result code
|
||
; CCR-- BEQ if the call was emulated, else BNE
|
||
;
|
||
; Trashes: D1-D2, A0-A1
|
||
;
|
||
; Function: Emulates all or part of the powerRead call ($18) for systems where not all
|
||
; power planes are controlled by the PMGR. On exit, the receive buffer will
|
||
; contain a byte with the following bits used:
|
||
;
|
||
; bit 0: 1=IWM power
|
||
; 1: 1=SCC power
|
||
; 2: 1=hard disk power
|
||
; 3: 1=internal modem power
|
||
; 4: 1=serial output driver power
|
||
; 5: 1=sound power
|
||
; 6: 1=minus 5 volt power
|
||
; 7: 1=turn on, 0=turn off devices corresponding to 1's in bits 0-6
|
||
;_______________________________________________________________________________________
|
||
|
||
MSCPowerStatus
|
||
MOVEQ #0,D1
|
||
MOVE.L A0,-(SP)
|
||
MOVE.W #Unimplement,D0 ; does the _DockingDispatch trap exist?
|
||
_GetTrapAddress ,NEWTOOL
|
||
MOVEA.L A0,A1
|
||
MOVE.W @DockTrap,D0
|
||
_GetTrapAddress ,NEWTOOL
|
||
CMPA.L A0,A1
|
||
BEQ.S @NoDocking ; -> no, just turn internal power planes on/off
|
||
SUBQ.W #4,SP ; result
|
||
PEA dockPowerStatus ; docking selector = power status
|
||
CLR.L -(SP) ; params = nil
|
||
@DockTrap _DockingDispatch ; call the handler
|
||
ADDQ.W #4,SP ; toss the result
|
||
@NoDocking MOVEM.L (SP)+,D1/A0
|
||
|
||
MOVEA.L VIA2,A1 ; point to the base of the MSC
|
||
MOVEQ #(1<<pSCC) | (1<<pSerDrvr),D0 ; mask off the SCC power and serial drivers bits
|
||
AND.B D1,D0 ; are either of them set?
|
||
BEQ.S @NoSCC ; -> nope
|
||
EOR.B D0,D1 ; turn them both off
|
||
TST.B D1 ; turn power on or off?
|
||
BMI.S @TurnOnSCC
|
||
BCLR #MSCSCCClk,MSCClkCntl(A1) ; turn off SCC PCLK, RTXC
|
||
BRA.S @NoSCC
|
||
@TurnOnSCC BSET #MSCSCCClk,MSCClkCntl(A1) ; turn on SCC PCLK, RTXC
|
||
|
||
@NoSCC BTST #pHD,D1 ; is hard disk power being turned on/off?
|
||
BEQ.S @NoHD ; -> no
|
||
TST.B D1 ; turn power on or off?
|
||
BMI.S @TurnOnSCSI
|
||
BCLR #MSCSCSIReset,MSCClkCntl(A1) ; drive SCSI chip reset low to stop clocks
|
||
BRA.S @NoHD
|
||
@TurnOnSCSI BSET #MSCSCSIReset,MSCClkCntl(A1) ; drive SCSI chip reset high to start it up
|
||
|
||
@NoHD BCLR #pASC,D1 ; is sound power being turned on/off?
|
||
BEQ.S @NoSound ; -> nope
|
||
TST.B D1 ; turn power on or off?
|
||
BMI.S @TurnOnSnd
|
||
BCLR #MSCSndPower,MSCSndCntl(A1) ; turn off sound power
|
||
BRA.S @NoSound
|
||
@TurnOnSnd BSET #MSCSndPower,MSCSndCntl(A1) ; turn off sound power
|
||
|
||
@NoSound BCLR #pIWM,D1 ; clear the SWIM power bit
|
||
|
||
@NoSWIM MOVEQ #$7F,D0 ; return BNE if any bits are still set
|
||
AND.B D1,D0 ; so we can pass it on to the PMGR
|
||
BNE.S @MorePower ; -> more for the PMGR to do <H31>
|
||
CLR.W pmLength(A0) ; fix the returned length since we're done <H31>
|
||
@MorePower RTS
|
||
|
||
;_______________________________________________________________________________________
|
||
;
|
||
; Routine: MSCFakePowerStatus
|
||
;
|
||
; Inputs: A0 -- pointer to caller's parameter block
|
||
;
|
||
; Outputs: CCR-- always BNE
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: This is a skanky way of letting us call the Power Manager and getting control
|
||
; back to do further processing. This converts the powerRead+1 command sent
|
||
; by the PowerStatus routine above into a powerRead command so it can get the
|
||
; status PG&E knows about before filling in the rest of the bits that are now
|
||
; handled by the MSC. What can I say? The price of extensibility?
|
||
;_______________________________________________________________________________________
|
||
|
||
MSCFakePowerStatus
|
||
SUBQ.W #$1F-powerRead,pmCommand(A0) ; convert this to a powerRead command ($18)
|
||
RTS ; get here with BNE to send the command to the PMGR
|
||
|
||
|
||
;_______________________________________________________________________________________
|
||
;
|
||
; Routine: MSCSetSound
|
||
;
|
||
; Inputs: A0 -- pointer to caller's parameter block
|
||
;
|
||
; Outputs: D0 -- result code
|
||
; CCR-- BEQ if the call was emulated, else BNE
|
||
;
|
||
; Trashes: D1,A1
|
||
;
|
||
; Function: Emulates the soundSet call ($90) for systems that don't control sound
|
||
; power and latch with the PMGR micro. The send buffer will contain a
|
||
; byte with the following bits used:
|
||
;
|
||
; bit 0: 1=sound power enabled
|
||
; 1: 1=clear sound latch
|
||
;_______________________________________________________________________________________
|
||
|
||
MSCSetSound CLR.W pmLength(A0) ; no bytes returned
|
||
MOVEA.L pmSBuffer(A0),A1 ; point to the transmit buffer
|
||
MOVEQ #3,D1 ; mask off valid bits
|
||
AND.B (A1),D1
|
||
MOVEA.L VIA2,A1 ; get the MSC's base address
|
||
MOVE.B @MSCSound(D1),MSCSndCntl(A1) ; stuff the right value into the sound control register
|
||
MOVEQ #0,D0 ; return "no error"
|
||
RTS
|
||
|
||
; on MSC, the sound latch is cleared simply by accessing the sound control register
|
||
|
||
@MSCSound DC.B (0<<MSCSndPower)|(0<<MSCSndBusy) ; [0] do nothing
|
||
DC.B (1<<MSCSndPower)|(0<<MSCSndBusy) ; [1] just turn on sound power
|
||
DC.B (0<<MSCSndPower)|(1<<MSCSndBusy) ; [2] turn off sound power, clear sound latch
|
||
DC.B (1<<MSCSndPower)|(1<<MSCSndBusy) ; [3] turn on sound power, clear sound latch
|
||
|
||
|
||
;_______________________________________________________________________________________
|
||
;
|
||
; Routine: MSCReadSound
|
||
;
|
||
; Inputs: A0 -- pointer to caller's parameter block
|
||
;
|
||
; Outputs: D0 -- result code
|
||
; CCR-- BEQ if the call was emulated, else BNE
|
||
;
|
||
; Trashes: D1,A1
|
||
;
|
||
; Function: Emulates the soundRead call ($98) for systems that don't control sound
|
||
; power and latch with the PMGR micro. On exit, the send buffer will contain
|
||
; a byte with the following bits used:
|
||
;
|
||
; bit 0: 1=sound power is on
|
||
; 1: 1=sound latch is set
|
||
;_______________________________________________________________________________________
|
||
|
||
MSCReadSound
|
||
MOVEA.L VIA2,A1 ; get the MSC's base address
|
||
MOVEQ #(1<<mscSndBusy)|(1<<MSCSndPower),D1
|
||
AND.B MSCSndCntl(A1),D1 ; mask off sound busy and sound power bits
|
||
BCLR #mscSndBusy,D1 ; is the sound latch set?
|
||
BEQ.S @NoLatch
|
||
ADDQ.B #(1<<1),D1 ; yes, set bit 1=1
|
||
@NoLatch MOVE.W #1,pmLength(A0) ; 1 byte returned
|
||
MOVEA.L pmRBuffer(A0),A1 ; point to the receive buffer
|
||
MOVE.B D1,(A1) ; and stuff in the result
|
||
MOVEQ #0,D0 ; return "no error"
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: CPUSpeedMSC
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: D0 - [maximum CPU speed][current CPU speed]
|
||
;
|
||
; Trashes: A0
|
||
;
|
||
; Function: returns the maximum and current (econo-mode or full) CPU speeds for
|
||
; MSC-based machines
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
CPUSpeedMSC MOVEA.L UnivInfoPtr,A0 ; point to our ProductInfo table
|
||
MOVEQ #7,D0 ; mask off the machine type from our CPU ID
|
||
AND.W CPUIDValue(A0),D0
|
||
MOVE.L @speedTable(D0.W*4),D0 ; get the maximum CPU speed in both halves <H9>
|
||
CMPI.W #CPUSpeed16MHz,D0 ; is this a 16MHz machine? <H9>
|
||
BLE.S @NoMSCEcono ; -> yes, econo-mode isn't supported <H9>
|
||
|
||
ADDA.L DecoderInfoPtr(A0),A0 ; point to our decoder table
|
||
MOVEA.L RBVAddr(A0),A0 ; then to the base of the MSC
|
||
BTST #MSCEconoBit,MSCConfig(A0) ; are we in econo-mode?
|
||
BEQ.S @NoMSCEcono ; -> nope <H8>
|
||
MOVE.W #CPUSpeed16MHz,D0 ; current speed is 16MHz
|
||
@NoMSCEcono RTS
|
||
|
||
@speedTable DC.W CPUSpeed33MHz, CPUSpeed33MHz ; ID=0 (boxYeager) <H71>
|
||
DC.W $484A , $5221 ; ID=1 (reserved HJR!) <H9>
|
||
DC.W CPUSpeed33MHz, CPUSpeed33MHz ; ID=2 (boxEscher) <H46>
|
||
DC.W CPUSpeed20MHz, CPUSpeed20MHz ; ID=3 (reserved-wasPenLite) <H71>
|
||
DC.W CPUSpeed25MHz, CPUSpeed25MHz ; ID=4 (boxDuo210) <H9>
|
||
DC.W CPUSpeed33MHz, CPUSpeed33MHz ; ID=5 (boxDuo230) <H9>
|
||
DC.W CPUSpeed16MHz, CPUSpeed16MHz ; ID=6 (boxDBLite16) <H9>
|
||
DC.W CPUSpeed16MHz, CPUSpeed16MHz ; ID=7 (reserved 16MHz) <H9>
|
||
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <H56>
|
||
; Routine: ChangeCPUSpeedMSC
|
||
;
|
||
; Inputs: D1 - ≠0: switch to reduced speed, =0: switch to full speed
|
||
;
|
||
; Outputs: D0 - =1: speed was changed, =0: speed was not changed
|
||
;
|
||
; Trashes: D1, A0
|
||
;
|
||
; Function: switches the CPU speed based on the passed parameter, and returns 1 if the
|
||
; speed change was actually done
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
ChangeCPUSpeedMSC
|
||
MOVEA.L VIA2,A1 ; point to the MSC's configuration register
|
||
LEA MSCConfig(A1),A1
|
||
MOVEQ #~(1<<EconoBit),D0 ; mask out the econo-mode bit
|
||
AND.B (A1),D0 ; in the configuration register
|
||
OR.B D0,D1 ; OR in the new setting
|
||
CMP.B (A1),D1 ; are we changing the setting?
|
||
BEQ.S @NoChange ; -> no
|
||
MOVE.B D1,(A1) ; yes, write out the new setting
|
||
|
||
MOVEQ #CPUSpeedDisp,D0 ; get the current CPU speed
|
||
_PowerDispatch
|
||
BCLR #MSC25MHz,(A1) ; assume 33MHz
|
||
CMPI.W #CPUSpeed25MHz,D0 ; are we running at 25MHz or less?
|
||
BGT.S @SpeedChanged ; -> no, we're done
|
||
BSET #MSC25MHz,(A1) ; yes, optimize the state machines for slower speed
|
||
@SpeedChanged
|
||
MOVEQ #1,D0
|
||
RTS
|
||
|
||
@NoChange MOVEQ #0,D0
|
||
RTS
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <H7>
|
||
; Routine: ClamshellVBL
|
||
;
|
||
; Inputs: A0 - pointer to VBL task queue element
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0,A0,A1
|
||
;
|
||
; Function: checks to see if the clamshell is closed, and if so, sets a flag so we can
|
||
; handle it at a _IdleMind time
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
ClamshellVBL
|
||
MOVE.W #ClamshellVBLFreq,vblCount(A0) ; reset the counter
|
||
|
||
MOVEA.L PMgrBase,A1 ; point to Power Manager variables
|
||
BTST #ignoreClamshell,PmgrFlags3(A1) ; what do we want to do? <H27>
|
||
BNE.S @InStation ; -> nothing <H27>
|
||
|
||
BTST #dockingStation,dockFlags(A1) ; are we in a docking station?
|
||
BNE.S @InStation ; -> yes, clamshell closed is OK
|
||
|
||
BTST #ClamshellClosed,PmgrFlags(A1) ; have we already detected the close?
|
||
BNE.S @Done ; -> yes, we're done this time
|
||
|
||
CLR.W -(SP)
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readExtSwitches,-(SP) ; pmCommand
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; get the clamshell info
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
BTST #clamshell,(SP)+ ; is the clamshell closed?
|
||
BEQ.S @Done ; -> nope, all done
|
||
|
||
BSET #ClamshellClosed,PmgrFlags(A1) ; flag that the clamshell is closed
|
||
@Done RTS
|
||
|
||
@InStation BCLR #ClamshellClosed,PmgrFlags(A1) ; flag that the clamshell is open
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: CheckClamshell (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, A0
|
||
;
|
||
; Function: does the appropriate thing if the clamshell was closed (sleep or nothing),
|
||
; and then runs the "standard" countdown checking code
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
CheckClamshell
|
||
BTST #InSleep,PmgrFlags(A2) ; IF !InSleep THEN
|
||
BNE @Exit ;
|
||
CLR.W -(SP) ; Setup PB for PmgrCommand
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readExtSwitches,-(SP) ; pmCommand = ReadSwitch
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; get the clamshell info
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
BTST #clamshell,(SP)+ ; IF ClamShell Open THEN
|
||
BNE.S @doClamshellClosed ;
|
||
BCLR.B #ClamshellClosed,PmgrFlags(A2) ; flag that the clamshell is open
|
||
BRA RunIdleRoutinesProc ; ELSE
|
||
|
||
@doClamshellClosed
|
||
BTST.B #ignoreClamshell,PmgrFlags3(A2) ; IF ignore Clamshell THEN
|
||
BNE.S @Exit ; bail
|
||
|
||
BTST.B #dockingStation,dockFlags(A2) ; ELSE IF in a dockingstation THEN
|
||
BNE.S @Exit ; bail
|
||
|
||
BSR CurFrontProcEqual ; ELSE IF Processes <> THEN
|
||
BEQ.S @Exit ; bail
|
||
|
||
BSET.B #ClamshellClosed,PmgrFlags(A2) ; ELSE IF Clamshell = closed THEN
|
||
BNE.S @Exit ; bail
|
||
|
||
MOVE.B PmgrFlags(A2),-(SP) ; ELSE save PmgrFlags
|
||
BSET #AvoidNetDiag,PmgrFlags(A2) ; and set the ‘no AppleTalk dialogs’ flag
|
||
MOVEQ #SleepNow,D0 ; force a sleep
|
||
_Sleep
|
||
BTST #AvoidNetDiag,(SP)+ ; was the ‘no AppleTalk dialogs’ flag set before?
|
||
BEQ.S @NoDialog ; -> no, leave it alone
|
||
BSET #AvoidNetDiag,PmgrFlags(A2) ; yes, restore it
|
||
@NoDialog MOVE.L Ticks,LastAct(A2) ; waking updates last activity
|
||
@Exit BRA RunIdleRoutinesProc ; ENDIF
|
||
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: SndWatchMSC
|
||
;
|
||
; Inputs: A0 - pointer to VBL task queue element
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, A0, A2
|
||
;
|
||
; Function: A VBL task called once every ten seconds that checks the sound latch for
|
||
; ASC new use. If so then sound power is turned on. If power is already on
|
||
; then then the latch is cleared. If the latch stays clear for two VBLs then
|
||
; sound power is turned off.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SndWatchMSC MOVE.W #SndWFreq,vblCount(A0) ; reset the counter
|
||
|
||
MOVEA.L VIA2,A0 ; point to the MSC's sound control register
|
||
LEA MSCSndCntl(A0),A0
|
||
BTST #MSCSndBusy,(A0) ; was sound used in the last 10 sec
|
||
BNE.S @SoundOn ; -> yes
|
||
|
||
MOVEA.L PMgrBase,A2 ; no, sound's been on but now it's not
|
||
TST.B SysTaskFlag(A2) ; are the sound input primitives set up?
|
||
BEQ.S @NoSoundAct ; -> no, there can't be a sound input source selected
|
||
|
||
jsrTBL sndInputSource ; is a sound source selected?
|
||
TST.B D0
|
||
BNE.S @NoSound ; -> yes, sound input is active so don't power off sound
|
||
|
||
@NoSoundAct BCLR #MSCSndPower,(A0) ; turn off sound power
|
||
RTS
|
||
|
||
@SoundOn BSET #MSCSndPower,(A0) ; turn on sound power (latch is cleared by any register access)
|
||
_IdleUpdateDispatch
|
||
@NoSound RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the volatile MSC chip registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveMSC MOVEA.L VIA2,A2 ; point to the base of the MSC
|
||
MOVEQ #$80-256,D0 ; save slot IER with bit 7 set so interrupts
|
||
OR.B MSCSlotIER(A2),D0 ; will be re-enabled upon wakeup
|
||
MOVE.B D0,-(SP)
|
||
MOVEQ #$80-256,D0 ; do the same with VIA2 IER
|
||
OR.B MSCVIA2IER(A2),D0
|
||
MOVE.B D0,-(SP)
|
||
BSET #MSCIOClk,MSCClkCntl(A2) ; make sure IOClk is on in case a bar's attached <H40>
|
||
MOVE.B MSCClkCntl(A2),-(SP) ; save the clock control register
|
||
JMP (A1) ; and return
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to have MSC turn off system power (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
MSCKillPower
|
||
MOVEA.L VIA2,A2 ; point to the power cycle/sleep register
|
||
ADDA.L #MSCPowerCycle,A2
|
||
MOVEQ #-1,D0
|
||
MOVE.L D0,(A2) ; write -1 to the register to kill the power
|
||
JMP (A1) ; we might optimistically get here
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore the volatile MSC chip registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreMSC MOVEA.L VIA2,A2 ; point to the base of the MSC
|
||
MOVE.B (SP)+,MSCClkCntl(A2) ; restore volatile registers
|
||
MOVE.B (SP)+,MSCVIA2IER(A2)
|
||
MOVE.B (SP)+,MSCSlotIER(A2)
|
||
JMP (A1) ; and return
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <H6>
|
||
; Wakeup routine to put the SCC into a known state (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
MSCInitSCC MOVEA.L VIA2,A2 ; turn on the internal SCC clock
|
||
BSET #MSCSCCClk,MSCClkCntl(A2)
|
||
|
||
MOVEA.L UnivInfoPtr,A2 ; point to the ProductInfo table
|
||
ADDA.L DecoderInfoPtr(A2),A2 ; then to the DecoderInfo table
|
||
MOVEM.L SCCRdAddr(A2),A2-A3 ; get the SCC base read/write addresses (channel B)
|
||
MOVEA.L VIA,A4 ; point to the VIA for delays
|
||
|
||
MOVE.B (A2),D0 ; do a read to make sure the SCC is synched up
|
||
TST.B (A4) ; delay a bit
|
||
MOVE.B #9,(A3) ; select register 9
|
||
TST.B (A4) ; delay some more
|
||
MOVE.B #$40,(A3) ; reset channel B
|
||
TST.B (A4) ; delay a little more
|
||
|
||
MOVEA.L VIA2,A2 ; turn off the internal SCC clock
|
||
BCLR #MSCSCCClk,MSCClkCntl(A2)
|
||
JMP (A1)
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: DBLiteModemType
|
||
;
|
||
; Input:
|
||
;
|
||
; Outputs: d0.l has the modem Type
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: Returns type of modem installed in DBLite Modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
DBLiteModemType
|
||
moveq.l #ModemTypeDUO,d0 ; dbmodem
|
||
rts
|
||
|
||
ENDIF ; {hasMSC}
|
||
|
||
|
||
IF hasNiagra THEN
|
||
;•••••••••••••••••••••••••••••••••••••••• Niagra •••••••••••••••••••••••••••••••••••••••••
|
||
|
||
EXPORT NiagraPmgrPrims
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypeTable ; padding, for now
|
||
DC.L (NiagraPmgrPrimsEnd-NiagraPmgrPrims); size of table
|
||
NiagraPmgrPrims ; Table of Niagra Primitives Tables
|
||
DC.L NiagraRoutines-NiagraPmgrPrims ; offset to table of NiagraRoutines
|
||
DC.L NiagraPrimInfo-NiagraPmgrPrims ; offset to decoder-specific constants
|
||
DC.L NiagraIdleMindTable-NiagraPmgrPrims ; offset to table of Idlemind routines
|
||
DC.L NiagraSleepTable-NiagraPmgrPrims ; offset to table of sleep routines
|
||
DC.L NiagraWakeTable-NiagraPmgrPrims ; offset to table of wakeup routines
|
||
DC.L NiagraPMgrOpExceptions-NiagraPmgrPrims; offset to PMgrOp exception table
|
||
DC.L NiagraModemTable-NiagraPmgrPrims ; offset to Modem Table <H31>
|
||
DC.L PwrDispatchVects-NiagraPmgrPrims ; offset to power dispatch table
|
||
DC.L PMgrHookVects-NiagraPmgrPrims ; offset to PMgr hook table
|
||
DC.L CommsPowerTable-NiagraPmgrPrims ; offset to table of comms power routines <K12>
|
||
DC.L PMgrOpTbl-NiagraPmgrPrims ; offset to routine for PmgrOp
|
||
DC.L 0 ; offset to backlight tables
|
||
NiagraPmgrPrimsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (NiagraRoutinesEnd-NiagraRoutines) ; size of table
|
||
NiagraRoutines ; Table of Niagra Specific Routines
|
||
DC.L PowerCycle030-NiagraRoutines ; offset to routine for power cycling down <H5>
|
||
DC.L Restore030-NiagraRoutines ; offset to routine for power cycling restore <H5>
|
||
DC.L BatWatch-NiagraRoutines ; offset to VBL task to check the battery level<H19>
|
||
DC.L GetLevel-NiagraRoutines ; offset to routine for determining battery level
|
||
DC.L LeadScaledBatteryInfo-NiagraRoutines; offset to routine to return scaled battery level <H15>
|
||
DC.L NiagraEnvInt-NiagraRoutines ; offset to environment interrupt handler
|
||
DC.L 0 ; no clamshellvbl
|
||
DC.L CPUSpeedNiagra-NiagraRoutines ; offset to routine for determining CPU speed
|
||
DC.L SndWatchPonti-NiagraRoutines ; offset to VBL task to check for sound usage <H19>
|
||
DC.L RedrawScrn-NiagraRoutines ; offset to routine for refreshing the screen <H17>
|
||
DC.L LeadAbsoluteBatteryVoltage-NiagraPmgrPrims; routine to return absolute battery level<H54>
|
||
DC.L 0 ; no routine to return info about battery times
|
||
DC.L 0 ; dynamic CPU speed change is not supported <H56>
|
||
NiagraRoutinesEnd
|
||
|
||
DC.L PrimsTypeInfo ; flags
|
||
DC.L (NiagraPrimInfoEnd-NiagraPrimInfo) ; size of table
|
||
NiagraPrimInfo ; machine-specific constants:
|
||
DC.B $46 ; PRAM base address <H14>
|
||
DC.B DefHysteresis ; default hysteresis
|
||
DC.B PMGRWARNLEVEL-STDOFFSET ; default low battery warning level <H5>
|
||
DC.B PMGRCUTOFF-STDOFFSET ; default dead battery warning level <H5>
|
||
DC.B PGMRWAKELEVEL-STDOFFSET ; hysteresis setting for pmgr wake level <H5>
|
||
DC.B (2-1) ; display shorted battery at second interrupt <H33>
|
||
DC.B 10 ; add 100mv to low bat warn if external video <H33>
|
||
DC.B 0 ; no charger features
|
||
DC.L $50FA0000 ; address of power cycling register <H7>
|
||
DC.L 0 |\ ; bitmap of Power Manager features <H52>
|
||
(0<<hasWakeupTimer) |\
|
||
(1<<hasSharedModemPort) |\
|
||
(1<<hasProcessorCycling) |\
|
||
(1<<mustProcessorCycle) |\
|
||
(1<<hasReducedSpeed) |\
|
||
(0<<dynamicSpeedChange) |\
|
||
(1<<hasSCSIDiskMode)
|
||
DC.L 0 |\ ; bitmap of private Power Manager features <H53>
|
||
(0<<hasExtdBattInfo) |\
|
||
(0<<hasBatteryID) |\
|
||
(0<<canSwitchPower)
|
||
DC.W 1 ; number of batteries
|
||
DC.B 0 ; Power Manager Parallel Interface
|
||
DC.B 0 ; padding for now
|
||
DC.L 0 ; no extended charge time
|
||
DC.B 0 ; value for power cycling register <K22>
|
||
DC.B 0 ; value for sleep register <K22>
|
||
DC.B 0 ; padding for now
|
||
DC.B 0 ; padding for now
|
||
NiagraPrimInfoEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (NiagraIdleMindTableEnd-NiagraIdleMindTable) ; size of table
|
||
NiagraIdleMindTable ; Machine specific Idlemind routines
|
||
DC.L CheckCountDownTimer-NiagraIdleMindTable ; offset to countdown timer
|
||
DC.L NiagraRunIdleRoutinesProc-NiagraIdleMindTable ; offset to run idle procs <H20>
|
||
DC.L ChkSleepTimeOut-NiagraIdleMindTable ; offset to check sleep
|
||
DC.L ChkIdle-NiagraIdleMindTable ; offset to check idle
|
||
DC.L CalcProgressive-NiagraIdleMindTable ; offset to calc progressive
|
||
DC.L GoPowerCycle-NiagraIdleMindTable ; offset to power cycle
|
||
NiagraIdleMindTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (NiagraSleepTableEnd-NiagraSleepTable) ; size of table
|
||
NiagraSleepTable ; list of routines to execute when going to sleep:
|
||
DC.L SleepHD-NiagraSleepTable ; sleep the hard drive if currently running
|
||
DC.L SaveVIA1-NiagraSleepTable ; save VIA1 registers
|
||
DC.L SaveASCBatmanDART-NiagraSleepTable ; save ASC/Batman registers <H29>
|
||
DC.L SoundPowerDownNiagra-NiagraSleepTable; power off sound <H29>
|
||
DC.L SaveFPU-NiagraSleepTable ; save FPU registers
|
||
DC.L SaveLCD-NiagraSleepTable ; save built-in LCD video registers
|
||
DC.L SaveVIA2-NiagraSleepTable ; save VIA2 registers
|
||
DC.L SendSleep-NiagraSleepTable ; send a sleep command
|
||
DC.L SaveSlp030-NiagraSleepTable ; save MMU registers
|
||
DC.L SaveSleepInfo-NiagraSleepTable ; save sleep info in video RAM
|
||
DC.L 0 ; (end of table)
|
||
NiagraSleepTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (NiagraWakeTableEnd-NiagraWakeTable) ; size of table
|
||
NiagraWakeTable ; list of routines to execute when waking up:
|
||
DC.L RestoreSlp030-NiagraWakeTable ; restore MMU, SPs, cache registers
|
||
DC.L RestoreVIA2-NiagraWakeTable ; restore VIA2 registers
|
||
DC.L RestoreLCD-NiagraWakeTable ; restore GSC (built-in LCD video) registers
|
||
DC.L RestoreFPU-NiagraWakeTable ; restore FPU registers
|
||
DC.L RestoreASCBatman-NiagraWakeTable ; restore ASC and Batman registers
|
||
DC.L RestoreDartAmp-NiagraWakeTable ; turn on amps <H29>
|
||
DC.L RestoreVIA1-NiagraWakeTable ; restore VIA1 registers
|
||
DC.L RestorePmgrMisc-NiagraWakeTable ; restore Misc PmgrVars
|
||
DC.L DockingWakeup-NiagraWakeTable ; restore state of currently connected bar <H10>
|
||
DC.L WakeClrInts-NiagraWakeTable ; clear any pending PmgrInterrupts
|
||
DC.L WakeSoundSetNiagra-NiagraWakeTable ; set state for sound out of sleep
|
||
DC.L 0 ; (end of table)
|
||
NiagraWakeTableEnd
|
||
|
||
DC.L PrimsTypePMgrEx ; flags
|
||
DC.L (NiagraPMgrOpExceptionsEnd-NiagraPMgrOpExceptions) ; size of table
|
||
NiagraPMgrOpExceptions ; PMgrOp exceptions:
|
||
DC.B $F0,$50 ; $5x - modem commands
|
||
DC.L DartModemCmds-* ;
|
||
DC.B $F7,$71 ; $71,$79 - modem commands
|
||
DC.L DartSPI-* ;
|
||
DC.B $F0,$A0 ; $Ax - modem commands
|
||
DC.L DartSPI-* ;
|
||
DC.W 0 ; (end of table)
|
||
NiagraPMgrOpExceptionsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (NiagraModemTableEnd-NiagraModemTable) ; size of table
|
||
NiagraModemTable
|
||
DC.L DartModemOn-NiagraModemTable ; offset to routine to turn on modem
|
||
DC.L DartModemOff-NiagraModemTable ; offset to routine to turn off modem
|
||
DC.L DartModemType-NiagraModemTable ; offset to routine to get modem type <K10>
|
||
NiagraModemTableEnd
|
||
|
||
ALIGN 4
|
||
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: DartModemCmds
|
||
;
|
||
; Input: A0 - points the pmgrop PB
|
||
;
|
||
; Destroys: d1
|
||
;
|
||
; Called by: Bra from NewPmgrOp
|
||
;
|
||
; Function: filter the modem $5X commands, $50 should still go the power manager
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
|
||
DartModemCmds
|
||
cmp.w #modemSet,pmCommand(A0)
|
||
bne.s DartSPI ; Handle call through SPI
|
||
moveq #1,d1 ; set CC to not handled here
|
||
rts ; return
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: DartSPI <H16>
|
||
;
|
||
; Input: A0 - points the pmgrop PB
|
||
;
|
||
; Destroys: d1
|
||
;
|
||
; Called by: Bra from NewPmgrOp
|
||
;
|
||
; Function: transfer data through new SPI port
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
|
||
DartSPI
|
||
@savedRegs REG D1-D4/A0-A3
|
||
|
||
|
||
; ----- dynamic test for SPI ----
|
||
movea.l PMgrBase,a3 ; point to the Power Manager's variables
|
||
btst.b #PmgrDartSPI,PmgrFlags1(a3) ; test if SPI modem installed
|
||
bne.s @SPIStart ; Handle call through SPI
|
||
moveq #1,d1 ; set CC to not handled here
|
||
rts ; return
|
||
|
||
@SPIStart
|
||
movem.l @savedRegs,-(sp)
|
||
MOVEA.L UnivInfoPtr,a2 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(a2),a2 ; then to the DecoderInfo table,
|
||
MOVEA.L JAWSAddr(a2),a2 ; then to the Niagra base address,
|
||
|
||
ADDA.L #NiagraGUR,a2 ; point to the base of the GUR space
|
||
|
||
; ----- send command and count ----
|
||
|
||
move.w pmCommand(a0),d3
|
||
move.w d3,d1
|
||
bsr SendSPI ; send command byte
|
||
bne.s @PMgrOpExit ; exit if error returned
|
||
|
||
MOVEA.L PMgrBase,A1 ; point to the Power Manager's variables
|
||
MOVEA.L vSendCountTbl(A1),A1 ; and get the send count table
|
||
move.w pmLength(a0),d2 ; pop the count into d2
|
||
tst.b (a1,d3)
|
||
bpl.s @noCount ; if positive, no count
|
||
|
||
move.w d2,d1
|
||
bsr SendSPI ; send count byte
|
||
bne.s @PMgrOpExit ; exit if error returned
|
||
|
||
; ----- send data ----
|
||
|
||
@noCount movea.l pmSBuffer(a0),a3 ; get the pointer to the command's data bytes
|
||
moveq #0,d1 ; (set CCR for BEQ so DBNE below won't fall thru)
|
||
bra.s @StartSend
|
||
|
||
@SendData MOVE.B (a3)+,D1 ; get the next data byte
|
||
BSR SendSPI ; and send it
|
||
@StartSend DBNE d2,@SendData ; -> more bytes to send
|
||
BNE.S @PMgrOpExit ; -> error
|
||
|
||
; ----- receive data -----
|
||
MOVEA.L PMgrBase,A1 ; point to the Power Manager's variables
|
||
MOVEA.L vRecvCountTbl(A1),A1 ; and get the receive count table
|
||
clr.l d4 ; clear count register
|
||
move.b (a1,d3),d4 ; initialize to count
|
||
bmi.s @readReplyCount ; (<0)
|
||
cmp.b #1,d4 ; test against 1
|
||
ble.s @readData ; if ( =0 or =1 ) go to read
|
||
subq #1,d4 ; (>1) correct count
|
||
bra.s @readData ; if 0 or 1 go to read
|
||
|
||
@readReplyCount
|
||
bsr ReceiveSPI ; read first byte for receive count
|
||
bne.s @PMgrOpExit ; exit if error returned
|
||
move.w d1,d4 ; move count into d4
|
||
|
||
@readData ; d4 has receive byte count
|
||
movea.l pmRBuffer(a0),a3 ; a3 new points
|
||
move.w d4,pmLength(a0) ;
|
||
bra.s @StartReceive ; start receiving data
|
||
|
||
@ReceiveByte
|
||
bsr.s ReceiveSPI ; read a byte into d1
|
||
bne.s @PMgrOpExit ; -> error
|
||
move.b d1,(a3)+ ; move data byte into buffer
|
||
|
||
@StartReceive
|
||
dbra d4,@ReceiveByte ; -> more bytes to send
|
||
|
||
@PMgrOpExit
|
||
moveq #0,d1 ; indicate we handled call
|
||
@exit
|
||
movem.l (sp)+,@savedRegs ; restore working registers
|
||
rts
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: WaitSPIAckHi
|
||
;
|
||
; Input: a2.l - pointer to GUR space
|
||
;
|
||
; Returns CCR - BNE if ACK went hi, BEQ if timed out
|
||
;
|
||
; Function: wait for SPI ack high
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
|
||
WaitSPIAckHi
|
||
@workRegs reg D1-d2
|
||
|
||
movem.l @workRegs,-(sp) ; save working set
|
||
moveq #32,d2 ; loop to max 32 msec
|
||
@nextmsec move.w timedbra,d1 ; 1 msec count
|
||
@waitAckhi btst.b #PontiSPIAck,PontiSPIMdmCtl(a2) ; test ack
|
||
dbne d1,@waitAckhi ; loop for upto 1 msec
|
||
dbne d2,@nextmsec ; loop for d2 msec
|
||
movem.l (sp)+,@workRegs
|
||
rts
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: WaitSPIAckLo
|
||
;
|
||
; Input: a2 - pointer to GUR space
|
||
;
|
||
; Returns CCR - BEQ if ACK went lo, BNE if timed out
|
||
;
|
||
; Function: wait for SPI ack lo
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
|
||
WaitSPIAckLo
|
||
@workRegs reg D1-d2
|
||
|
||
movem.l @workRegs,-(sp) ; save working set
|
||
moveq #32,d2 ; loop to max 32 msec
|
||
@nextmsec move.w timedbra,d1 ; 1 msec count
|
||
@waitAcklo btst.b #PontiSPIAck,PontiSPIMdmCtl(a2) ; test ack
|
||
dbeq d1,@waitAcklo ; loop for upto 1 msec
|
||
dbeq d2,@nextmsec ; loop for d2 msec
|
||
movem.l (sp)+,@workRegs
|
||
rts
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: SendSPI
|
||
;
|
||
; Input: a2.l - pointer to GUR space
|
||
; d1.b - byte to send
|
||
;
|
||
; Returns d0.w - 0 = ok, non-zero = error
|
||
;
|
||
; Function: send a byte thru the SPI
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
|
||
SendSPI MOVE.W #pmSendStartErr,D0 ; assume a send error
|
||
bsr.s WaitSPIAckHi ; (1) wait for pmgr idle
|
||
beq.s @error ; if bit low, error
|
||
;begin transaction
|
||
bset.b #PontiLmpSPIDir,PontiLmpSftCtl(a2) ; (2) set direction to output
|
||
move.b d1,PontiSPISftReg(a2) ; (3) write data
|
||
bclr.b #PontiSPIReq,PontiSPIMdmCtl(a2) ; (4) assert data valid
|
||
bsr.s WaitSPIAckLo ; (5) --> modem shift data
|
||
; (6) wait for data accepted
|
||
bne.s @error ; if bit low, error
|
||
bset.b #PontiSPIReq,PontiSPIMdmCtl(a2) ; (7) clear data valid
|
||
|
||
MOVEQ #noErr,D0 ; report no error
|
||
@error tst.w d0
|
||
rts
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: ReceiveSPI
|
||
;
|
||
; Input: a2.l - pointer to GUR space
|
||
; d1.b - byte to send
|
||
;
|
||
; Returns d0.w - 0 = ok, non-zero = error
|
||
;
|
||
; Function: read a byte from the spi
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
|
||
ReceiveSPI MOVE.W #pmRecvStartErr,D0 ; assume a receive error
|
||
bsr.s WaitSPIAckHi ; (1) wait for pmgr idle
|
||
beq.s @error ; if bit low, error
|
||
|
||
;begin transaction
|
||
bclr.b #PontiLmpSPIDir,PontiLmpSftCtl(a2) ; (2) set direction to input
|
||
bclr.b #PontiSPIReq,PontiSPIMdmCtl(a2) ; (3) (RFD) ready for data
|
||
bsr.s WaitSPIAckLo ; (4) acknowledge req
|
||
; (5) <-- modem shifting
|
||
bne.s @error ; if bit low, error
|
||
bset.b #PontiSPIReq,PontiSPIMdmCtl(a2) ; (6) acknowledge ack
|
||
|
||
bsr.s WaitSPIAckHi ; (7) wait (DAV)
|
||
beq.s @error ; if bit low, error
|
||
move.b PontiSPISftReg(a2),d1 ; (8) read data
|
||
|
||
MOVEQ #noErr,D0 ; report no error
|
||
@error tst.w d0
|
||
rts
|
||
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: CPUSpeedNiagra
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: D0 - [maximum CPU speed][current CPU speed]
|
||
;
|
||
; Trashes: D1, A0
|
||
;
|
||
; Function: returns the maximum and current (econo-mode or full) CPU speeds for
|
||
; Niagra-based machines
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
CPUSpeedNiagra
|
||
MOVEA.L UnivInfoPtr,A0 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(A0),A0 ; then to the DecoderInfo table,
|
||
MOVEA.L JawsAddr(A0),A0 ; then to the JAWS base address,
|
||
ADDA.L #NiagraSpeedReg,A0 ; and finally to the CPU clock register
|
||
MOVEQ #%00000011,D1 ; only care about last two bits
|
||
AND.B (A0),D1 ;
|
||
LSL.B #2,D1 ; convert to long words
|
||
MOVE.L @CPUSpeedNiagraTable(D1.W),D0 ; get our table entry
|
||
|
||
ADDA.L #JAWSEconoMode-NiagraSpeedReg,A0; (point to the econo-mode register)
|
||
BTST #1,(A0) ; IF inEconoMode THEN
|
||
BNE.S @InEcono ; Exit we're done
|
||
MOVE.W @CPUSpeedNiagraTable(D1.W),D0 ; Else we are running full speed
|
||
@InEcono RTS
|
||
|
||
@CPUSpeedNiagraTable
|
||
DC.W CPUSpeed16MHz,CPUSpeed16MHz
|
||
DC.W CPUSpeed20MHz,CPUSpeed16MHz
|
||
DC.W CPUSpeed25MHz,CPUSpeed16MHz
|
||
DC.W CPUSpeed33MHz,CPUSpeed16MHz
|
||
|
||
|
||
ALIGN 4
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: NiagraRunIdleRoutinesProc (IdleMind) <H20>
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, A0
|
||
;
|
||
; Function: does the appropriate thing if the shutdown request bit is set
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
NiagraRunIdleRoutinesProc
|
||
btst.b #PmgrShutdownReq,PmgrFlags1(A2) ; test request
|
||
BEQ.S @exitSoftReset ; exit if no request
|
||
movea.l vSoftShutdown(a2),a0 ;
|
||
jsr (a0) ; call shutdown vector
|
||
bne.s @exitSoftReset ; if error, don't clear flag
|
||
bclr.b #PmgrShutdownReq,PmgrFlags1(A2) ; clear request
|
||
@exitSoftReset
|
||
|
||
; Convienient place to check whether a notification message must be posted regarding <H34>
|
||
; the use of external video and the charger. If the user boots or wakes the machine |
|
||
; with an external monitor but no charger, then external video will be disabled by the v
|
||
; primaryInit code. PrimaryInit will also set the flag "PmgrExtVidAlrt" indicating
|
||
; the condition for a warning to be posted. If while external video is on, and the
|
||
; charger is disconnected, a different warning should be posted about the hardware
|
||
; becoming unstable unless the charger is attached.
|
||
|
||
BCLR #PmgrExtVidAlrt,PmgrFlags1(A2) ; IF AlertUser THEN
|
||
BEQ.S @NoVidAlrt ; .
|
||
MOVE.L NoVidSTRPtr(a2),a0 ; Load Appropriate String
|
||
MOVEQ #1,d0 ; Tell Message Handler to use completion routine
|
||
BRA.S @postMsg ; Post Message
|
||
@NoVidAlrt
|
||
BTST #PmgrExtVidOn,PmgrFlags1(a2) ; IF External Video THEN
|
||
BEQ.S @Cont ; .
|
||
BTST #HasCharger,Charger(a2) ; IF ChargerNotConnected THEN
|
||
BNE.S @clearFlag ; .
|
||
MOVE.L NoChrgrSTRPtr(a2),a0 ; Get handle to alert string
|
||
MOVEQ #0,d0 ; Set empty completion routine
|
||
@postMsg BSR PostUserNmMsg ; Post the notification mgr message
|
||
BRA.S @Cont
|
||
@clearFlag ; ELSE
|
||
BTST #PmgrAvoidUsrMsg,PmgrFlags1(a2) ; IF warning messages enabled THEN
|
||
BEQ.S @Cont ; .
|
||
LEA UNmQEntry(a2),a0 ; Get address of notification record
|
||
_NMRemove ; Remove Message
|
||
BCLR #PmgrAvoidUsrMsg,PmgrFlags1(a2) ; after doing NMRemove then clr flag (steve)
|
||
|
||
@Cont BRA RunIdleRoutinesProc ; Continue with RunIdle
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: DartModemOn
|
||
;
|
||
; Input: a0.l = ptr to powermanager pb + 4 byte general data buffer
|
||
; d1.b = modem status bits from power manager
|
||
;
|
||
; Outputs: condition codes
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: turn Power on to the internal dartanian modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
DartModemOn
|
||
bsr StdModemOn ; turn on the modem the standard way
|
||
|
||
; test for spi
|
||
move.l a2,-(sp) ; save a2
|
||
movea.l UnivInfoPtr,a2 ; point to the ProductInfo table,
|
||
adda.l DecoderInfoPtr(a2),a2 ; then to the DecoderInfo table,
|
||
movea.l JAWSAddr(a2),a2 ; then to the Niagra base address,
|
||
adda.l #NiagraGUR,a2 ; and finally general utility register space
|
||
;
|
||
bclr.b #PmgrDartSPI, \ ;
|
||
([PmgrBase],PmgrFlags1) ; preset - disable spi interface
|
||
btst.b #PontiSPIMdmId,PontiSPIMdmCtl(a2); check the new modem interface bit (spi)
|
||
beq.s @exitSPI ; if not set, old modem, exit CCR set
|
||
|
||
bset.b #PmgrDartSPI,\
|
||
([PmgrBase],PmgrFlags1) ; enable spi interface
|
||
bclr.b #PontiSndSPIIrqMsk,PontiSndCtl(a2); enable spi interrupts
|
||
moveq.l #1,d0 ; set CCR, don't turn on power to SCC
|
||
|
||
@exitSPI move.l (sp)+,a2 ; restore a2
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: DartModemOff
|
||
;
|
||
; Input: a0.l = ptr to powermanager pb + 4 byte general data buffer
|
||
; d1.b = modem status bits from power manager
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: turn Power off to the internal dartanian modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
DartModemOff ;
|
||
move.l a2,-(sp) ; save a2
|
||
movea.l UnivInfoPtr,a2 ; point to the ProductInfo table,
|
||
adda.l DecoderInfoPtr(a2),a2 ; then to the DecoderInfo table,
|
||
movea.l JAWSAddr(a2),a2 ; then to the Niagra base address,
|
||
adda.l #NiagraGUR+PontiSndCtl,a2 ; and finally to the modem register
|
||
bclr.b #PmgrDartSPI,\
|
||
([PmgrBase],PmgrFlags1) ; disable spi interface
|
||
bset.b #PontiSndSPIIrqMsk,(a2) ; disable spi interrupts
|
||
bsr StdModemOff ; power off modem the standard way
|
||
move.l (sp)+,a2 ; restore a2
|
||
RTS
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <K10>
|
||
; Routine: DartModemType
|
||
;
|
||
; Input:
|
||
;
|
||
; Outputs: d0.l has the modem Type
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: Returns type of modem installed in Dartanian Modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
DartModemType
|
||
move.l a0,-(sp)
|
||
|
||
moveq.l #ModemTypeSerial,d0 ; assume serialmodem
|
||
movea.l UnivInfoPtr, a0 ; point to product info table,
|
||
movea.l DecoderInfoPtr(a0), a0 ; then to the DecoderInfo table,
|
||
movea.l JAWSAddr(a0),a0 ; then to the Niagra base address,
|
||
adda.l #NiagraGUR+PontiSPIMdmCtl, a0 ; and finally to the modem ctl register
|
||
btst.b #PontiSPIMdmId,(a0) ; test the modem bit
|
||
beq.s @exit
|
||
moveq.l #ModemTypeDUOPlus,d0 ; load new modem id
|
||
|
||
@exit movem.l (sp)+,a0
|
||
rts
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: SndWatchPonti
|
||
;
|
||
; Inputs: A0 - pointer to VBL task queue element
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, A0, A2
|
||
;
|
||
; Function: A VBL task called once every ten seconds that checks the sound latch for
|
||
; ASC new use. If so then sound power is turned on. If power is already on
|
||
; then then the latch is cleared. If the latch stays clear for two VBLs then
|
||
; sound power is turned off.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SndWatchPonti
|
||
MOVE.W #SndWFreq,vblCount(A0) ; reset the counter
|
||
|
||
MOVEA.L UnivInfoPtr,A0 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(A0),A0 ; then to the DecoderInfo table,
|
||
MOVEA.L JAWSAddr(A0),A0 ; then to the Niagra base address,
|
||
ADDA.L #NiagraGUR+PontiSndCtl,A0 ; and finally to the sound register
|
||
|
||
BTST #PontiSndLatchData,(A0) ; was sound used in the last 10 sec
|
||
BNE.S @SoundOn ; -> yes
|
||
|
||
MOVEA.L PMgrBase,A2 ; no, sound's been on but now it's not
|
||
TST.B SysTaskFlag(A2) ; are the sound input primitives set up?
|
||
BEQ.S @NoSoundAct ; -> no, there can't be a sound input source selected
|
||
|
||
jsrTBL sndInputSource ; is a sound source selected?
|
||
TST.B D0
|
||
BNE.S @NoSound ; -> yes, sound input is active so don't power off sound
|
||
|
||
@NoSoundAct BCLR #PontiSndPwrOn,(A0) ; turn off sound power
|
||
RTS
|
||
|
||
@SoundOn BSET #PontiSndPwrOn,(A0) ; turn on sound power
|
||
BSET #PontiSndLatchClr,(A0) ; pulse (positive) latch clear bit
|
||
BCLR #PontiSndLatchClr,(A0)
|
||
_IdleUpdateDispatch
|
||
@NoSound RTS
|
||
|
||
|
||
;________________________________________________________________________________________
|
||
;
|
||
; Routine: NiagraEnvInt
|
||
;
|
||
; Inputs: A0 - pointer to PMGR interrupt data: [flags][battery][gas][therm]
|
||
; A1 - pointer to VIA1 base
|
||
; A2 - pointer to Power Manager's variables
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: none (D0-D3 and A0-A3 are preserved by the interrupt dispatcher)
|
||
;
|
||
; Function: Handles PMGR environment interrupts by attempting a soft shutdown, if allowed.
|
||
;________________________________________________________________________________________
|
||
|
||
NiagraEnvInt
|
||
_IdleUpdateDispatch
|
||
btst.b #ScsiDiskModeOn,PmgrFlags(a2) ; check for scsi disk mode
|
||
beq.s @normalRequest ; if not, continue
|
||
_PowerOff ; ... else power off
|
||
bra.s * ; ... wait for the plug
|
||
|
||
@normalRequest
|
||
btst.b #PmgrShutdownEnb,PmgrFlags1(a2) ; is shutdown allowed
|
||
beq.s @exit ; if not just exit
|
||
bset.b #PmgrShutdownReq,PmgrFlags1(a2) ; set shutdown request
|
||
@exit rts
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to poweroff Sound (A1 = return address) <H29>
|
||
;———————————————————————————————————————————————————————————————————————————————————————— |
|
||
SoundPowerDownNiagra ; V
|
||
MOVEA.L UnivInfoPtr,A0 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(A0),A0 ; then to the DecoderInfo table,
|
||
MOVEA.L JAWSAddr(A0),A0 ; then to the Niagra base address,
|
||
ADDA.L #NiagraGUR+PontiSndCtl,A0 ; and finally to the sound register
|
||
;
|
||
BSET #PontiSndLatchClr,(A0) ; pulse (positive) latch clear bit
|
||
BCLR #PontiSndLatchClr,(A0) ;
|
||
;
|
||
BCLR #PontiSndPwrOn,(A0) ; turn off sound power
|
||
;
|
||
JMP (A1) ; and return
|
||
|
||
ENDIF ; {hasNiagra} IF hasNiagra THEN
|
||
|
||
IF hasPratt THEN
|
||
;•••••••••••••••••••••••••••••••••••••••• Pratt •••••••••••••••••••••••••••••••••••••••••
|
||
EXPORT PrattPmgrPrims
|
||
import PrattBkltPrims
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypeTable ; flags
|
||
DC.L (PrattPmgrPrimsEnd-PrattPmgrPrims) ; size of table
|
||
PrattPmgrPrims ; Table of Primitives tables
|
||
DC.L PrattRoutines-PrattPmgrPrims ; offset to table of Pratt routines
|
||
DC.L PrattPrimInfo-PrattPmgrPrims ; offset to decoder-specific constants
|
||
DC.L PrattIdleMindTable-PrattPmgrPrims ; offset to table of Idlemind routines
|
||
DC.L PrattSleepTable-PrattPmgrPrims ; offset to table of sleep routines
|
||
DC.L PrattWakeTable-PrattPmgrPrims ; offset to table of wakeup routines
|
||
DC.L PrattPMgrOpExceptions-PrattPmgrPrims; offset to PMgrOp exception table
|
||
DC.L PrattModemTable-PrattPmgrPrims ; offset to table of modem routines
|
||
DC.L PwrDispatchVects-PrattPmgrPrims ; offset to table of PwrDispatchVects
|
||
DC.L PMgrHookVects-PrattPmgrPrims ; offset to table of PmgrMgr Hooks
|
||
DC.L PrattCommsPowerTable-PrattPmgrPrims ; offset to table of comms power routines <K12>
|
||
DC.L PMgrOpTbl-PrattPmgrPrims ; offset to table for PmgrOp
|
||
DC.L PrattBkltPrims-PrattPmgrPrims ; offset to backlight tables
|
||
PrattPmgrPrimsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (PrattRoutinesEnd-PrattRoutines) ; size of table
|
||
PrattRoutines ; machine-specific routines
|
||
DC.L PowerCycle040-PrattRoutines ; offset to routine for power cycling
|
||
DC.L Restore040-PrattRoutines ; offset to routine for power cycling restore
|
||
DC.L BatWatch-PrattRoutines ; offset to VBL task to check the battery level
|
||
DC.L GetExtLevelPratt-PrattRoutines ; offset to routine for determining battery level
|
||
DC.L MultiScaledBatteryInfo-PrattRoutines; offset to routine to return scaled battery level
|
||
DC.L 0 ; no environment interrupts
|
||
DC.L CPUSpeedMSC-PrattRoutines ; offset to routine for determining CPU speed
|
||
DC.L SndWatchPratt-PrattRoutines ; offset to VBL task to check for sound usage
|
||
DC.L RedrawScrn-PrattRoutines ; offset to routine for refreshing the screen
|
||
DC.L PGEAbsoluteBatteryVoltage-PrattRoutines ; routine to return absolute battery level <H54>
|
||
DC.L PrattGetBatteryTimes-PrattRoutines ; routine to return info about battery times
|
||
DC.L 0 ; dynamic CPU speed change is not supported
|
||
PrattRoutinesEnd
|
||
|
||
DC.L PrimsTypeInfo ; flags
|
||
DC.L (PrattPrimInfoEnd-PrattPrimInfo) ; size of table
|
||
PrattPrimInfo ; machine-specific constants:
|
||
DC.B $46 ; PRAM base address
|
||
DC.B DefHysteresis ; default hysteresis
|
||
DC.B 40 ; default low battery warning level (20%)
|
||
DC.B 10 ; default dead battery warning level (5%)
|
||
DC.B 0 ; hysteresis setting for wake level (none)
|
||
DC.B 0 ; shorted battery at first interrupt (none)
|
||
DC.B 0 ; no external video correction needed
|
||
DC.B 0 ; no charger features
|
||
DC.L $5008001B ; address of power cycling register
|
||
DC.L 0 |\ ; bitmap of Power Manager features
|
||
(0<<hasWakeupTimer) |\
|
||
(1<<hasSharedModemPort) |\
|
||
(1<<hasProcessorCycling) |\
|
||
(1<<mustProcessorCycle) |\
|
||
(0<<hasReducedSpeed) |\
|
||
(0<<dynamicSpeedChange) |\
|
||
(1<<hasSCSIDiskMode)
|
||
DC.L 0 |\ ; bitmap of private Power Manager features <H53>
|
||
(1<<hasExtdBattInfo) |\
|
||
(1<<hasBatteryID) |\
|
||
(0<<canSwitchPower)
|
||
DC.W 1 ; number of batteries
|
||
DC.B 2 ; Power Manager Serial Interface
|
||
DC.B 0 ; padding for now
|
||
DC.L 0 ; no extended charging
|
||
DC.B $01 ; value for power cycling register <K22>
|
||
DC.B 0 ; value for sleep register <K22>
|
||
DC.B 0 ; padding for now
|
||
DC.B 0 ; padding for now
|
||
PrattPrimInfoEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (PrattIdleMindTableEnd-PrattIdleMindTable) ; size of table
|
||
PrattIdleMindTable ; machine specific IdleMind Routines
|
||
DC.L CheckCountDownTimer-PrattIdleMindTable; offset to count down timer
|
||
DC.L CheckClamshell-PrattIdleMindTable ; offset to clam shell
|
||
DC.L ChkSleepTimeOut-PrattIdleMindTable ; offset to sleep time out
|
||
DC.L ChkIdle-PrattIdleMindTable ; offset to check idle
|
||
DC.L CalcProgressive-PrattIdleMindTable ; offset to calc progressive
|
||
DC.L GoPowerCycle-PrattIdleMindTable ; offset to go power cycle
|
||
PrattIdleMindTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (PrattSleepTableEnd-PrattSleepTable); size of table
|
||
PrattSleepTable ; list of routines to execute when going to sleep:
|
||
DC.L SleepHD-PrattSleepTable ; sleep the hard drive if currently running
|
||
DC.L DockingSleep-PrattSleepTable ; save state of currently connected bar
|
||
DC.L EnetSleep-PrattSleepTable ; sleep the onboard Enet <K17>
|
||
DC.L SaveLCD-PrattSleepTable ; save GSC (built-in LCD video) registers
|
||
DC.L SaveFPU-PrattSleepTable ; save FPU registers
|
||
DC.L SaveVIA1-PrattSleepTable ; save VIA1 registers
|
||
DC.L SaveVIA2-PrattSleepTable ; save VIA2 registers
|
||
DC.L SaveWhitney-PrattSleepTable ; save Whitney registers
|
||
DC.L SaveSlp040-PrattSleepTable ; save MMU registers
|
||
DC.L SaveSleepInfo-PrattSleepTable ; save sleep info in Power Manager globals
|
||
DC.L SendSleep-PrattSleepTable ; send a sleep command
|
||
DC.L 0 ; (end of table)
|
||
PrattSleepTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (PrattWakeTableEnd-PrattWakeTable) ; size of table
|
||
PrattWakeTable ; list of routines to execute when waking up:
|
||
DC.L RestoreSlp040-PrattWakeTable ; restore MMU, SPs, cache registers
|
||
DC.L RestoreWhitney-PrattWakeTable ; restore Whitney registers
|
||
DC.L RestoreVIA2-PrattWakeTable ; restore VIA2 registers
|
||
DC.L RestoreVIA1-PrattWakeTable ; restore VIA1 registers
|
||
DC.L RestoreFPU-PrattWakeTable ; restore FPU registers
|
||
DC.L RestoreLCD-PrattWakeTable ; restore CSC (built-in LCD video) registers
|
||
DC.L EnetWake-PrattWakeTable ; wake the onboard Enet <K17>
|
||
DC.L DockingWakeup-PrattWakeTable ; restore state of currently connected bar
|
||
DC.L WakeClrInts-PrattWakeTable ; clear any pending PmgrInterrupts
|
||
DC.L 0 ; (end of table)
|
||
PrattWakeTableEnd
|
||
|
||
DC.L PrimsTypePMgrEx ; flags
|
||
DC.L (PrattPMgrOpExceptionsEnd-PrattPMgrOpExceptions) ; size of table
|
||
PrattPMgrOpExceptions ; PMgrOp exceptions:
|
||
DC.B $F7,SetModemInts ; $71,$79 - modem commands
|
||
DC.L PrattModemOp-* ;
|
||
DC.W 0 ; none for the moment
|
||
PrattPMgrOpExceptionsEnd
|
||
|
||
DC.L PrimsTypePtr ; flags <K10>
|
||
DC.L (PrattModemTableEnd-PrattModemTable); size of table
|
||
PrattModemTable
|
||
DC.L 0 ; offset to routine to turn on modem
|
||
DC.L 0 ; offset to routine to turn off modem
|
||
DC.L BlackBirdModemType-PrattModemTable ; offset to routine to get modem type
|
||
PrattModemTableEnd
|
||
|
||
DC.L PrimsTypePtr ; flags <K12>
|
||
DC.L (PrattCommsPowerTableEnd-PrattCommsPowerTable); number of entries
|
||
PrattCommsPowerTable
|
||
@PwrOn DC.L 0 ; no Port B serial
|
||
DC.L PrattPortAOn-PrattCommsPowerTable ; A serial
|
||
DC.L PortCOn-PrattCommsPowerTable ; C serial (internal modem)
|
||
DC.L PrattSonicOn-PrattCommsPowerTable ; onboard ethernet
|
||
|
||
@PwrOff DC.L 0 ; no Port B serial
|
||
DC.L PrattPortAOff-PrattCommsPowerTable ; A serial
|
||
DC.L PortCOff-PrattCommsPowerTable ; C serial (internal modem)
|
||
DC.L PrattSonicOff-PrattCommsPowerTable ; onboard ethernet
|
||
PrattCommsPowerTableEnd
|
||
ALIGN 4
|
||
|
||
ENDIF
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <K26> thru
|
||
; Routine: GetExtLevelPratt |
|
||
; v
|
||
; Inputs: A2 - pointer to Power Manager globals
|
||
;
|
||
; Outputs: D0 - normalized battery level (-1 to 4)
|
||
; CCR - BNE if a valid battery level is being returned
|
||
;
|
||
; Trashes: D0-D3, A0
|
||
;
|
||
; Function: Reads the extended battery power level from the Power Manager (which is
|
||
; pre-averaged by the PMGR). Next, the value is compared with the warning
|
||
; and cutoff values in the globals. Warning being the first alert, midway from
|
||
; warning to cutoff being the second, and the cutoff being the 10 second
|
||
; countdown.
|
||
;
|
||
; Note: The extended battery status command supports a word-sized battery
|
||
; level. Currently the PMGR on Blackbird returns a value in half
|
||
; percentages, that is from 0-200.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
GetExtLevelPratt
|
||
CLR.L -(SP)
|
||
CLR.L -(SP)
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readExtBatt,-(SP) ; pmCommand = get extended battery data
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
|
||
MOVEA.L SP,A0 ; point to the buffer
|
||
MOVEQ #%00001011,D0 ; mask off the bits we want in the flags byte,
|
||
AND.B (A0),D0
|
||
MOVE.B Charger(A2),D1 ; get the old charger state,
|
||
MOVE.B D0,Charger(A2) ; and save the new charger state
|
||
MOVE.B (A0)+,D0 ; get the unmodified flags
|
||
EOR.B D0,D1 ; has the charger state changed since last time?
|
||
BTST #HasCharger,D1 ;
|
||
BEQ.S @ChargeSame ; -> no
|
||
ST TOdirtyFlag(A2) ; yes, flag that timeouts need updating
|
||
|
||
@ChargeSame MOVE.W (A0),D3
|
||
MOVE.B D3,BatAvg(A2) ; save the 8-bit battery voltage
|
||
ADDQ.W #8,SP ; toss the buffer
|
||
|
||
BTST #HasCharger,D0 ; is a charger connected?
|
||
BNE.S @HaveCharger ; -> yes, we don't care about the battery level
|
||
BTST #2,D0 ; is a battery connected?
|
||
BEQ.S @HaveCharger ; -> no, don't bother with battery level
|
||
|
||
|
||
MOVEQ #0,D0 ; level 0
|
||
CMP.B LowWarn(A2),D3 ;
|
||
BHI.S @foundlevel
|
||
|
||
MOVEQ #1,D0 ; level 1
|
||
MOVEQ #0,D1 ; clr register
|
||
MOVE.B LowWarn(A2),D1 ; get low-warning level
|
||
ADD.B CutOff(A2),D1 ; add cutoff
|
||
LSR.B #1,D1 ; average the two
|
||
CMP.B D1,D3 ; are we there yet?
|
||
BHI.S @foundlevel ;
|
||
|
||
MOVEQ #3,D0 ; level 3
|
||
CMP.B CutOff(A2),D3 ; are we at cutoff yet?
|
||
BHI.S @foundlevel ;
|
||
|
||
MOVEQ #4,D0 ; level 4
|
||
BRA.S @foundlevel ; 10 second countdown
|
||
|
||
@HaveCharger
|
||
MOVEQ #-1,D0 ; return a "charged" battery level in case someone cares
|
||
|
||
@foundlevel MOVEQ #1,D1 ; always return BNE for data valid
|
||
RTS
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: SndWatchPratt
|
||
;
|
||
; Inputs: A0 - pointer to VBL task queue element
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, A0, A2
|
||
;
|
||
; Function: A VBL task called once every ten seconds that checks the sound latch for
|
||
; ASC new use. If so then sound power is turned on. If power is already on
|
||
; then then the latch is cleared. If the latch stays clear for two VBLs then
|
||
; sound power is turned off.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SndWatchPratt
|
||
MOVE.W #SndWFreq,vblCount(A0) ; reset the counter
|
||
|
||
MOVEA.L ASCBase,A0 ; point to the ProductInfo table,
|
||
LEA wSndControl(A0),A0 ; A0 = Ptr to Sound Control Register
|
||
BTST #wSingerSNDFlag,(A0) ; IF wSingerSNDFlag THEN
|
||
BNE.S @SoundOn ; there was a sound in the last 10 sec
|
||
|
||
MOVEA.L PMgrBase,A2 ; no, sound's been on but now it's not
|
||
TST.B SysTaskFlag(A2) ; are the sound input primitives set up?
|
||
BEQ.S @NoSoundAct ; -> no, there can't be a sound input source selected
|
||
|
||
jsrTBL sndInputSource ; is a sound source selected?
|
||
TST.B D0
|
||
BNE.S @NoSound ; -> yes, sound input is active so don't power off sound
|
||
|
||
@NoSoundAct BCLR #wSingerPower,(A0) ; turn off sound power
|
||
RTS
|
||
|
||
@SoundOn BSET #wSingerPower,(A0) ; turn on sound power
|
||
BSET #wSingerSNDFlag,(A0) ; Clear the latch
|
||
_IdleUpdateDispatch ;
|
||
@NoSound RTS ; <K26>
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: PrattGetBatteryTimes
|
||
;
|
||
; Inputs: - pointer to BatteryTimeRec record:
|
||
; expectedBatteryTime DS.L 1 ; estimated battery time remaining
|
||
; minimumBatteryTime DS.L 1 ; minimum battery time remaining
|
||
; maximumBatteryTime DS.L 1 ; maximum battery time remaining
|
||
; timeUntilCharged DS.L 1 ; time remaining until the battery is fully charged
|
||
; D0 - high word: system total (0) - battery number (1-n)
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: A0-A1, D0-D2
|
||
;
|
||
; Function: fills in a record containing fields that describe battery times.
|
||
;________________________________________________________________________________________
|
||
PrattGetBatteryTimes
|
||
|
||
@NoBattery CLR.L (A0)+ ; zero out the fields
|
||
CLR.L (A0)+
|
||
CLR.L (A0)+
|
||
CLR.L (A0)+
|
||
MOVEQ #0,D0
|
||
RTS
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: PrattModemOp
|
||
;
|
||
; Input: A0 - points the pmgrop PB
|
||
;
|
||
; Destroys: d1
|
||
;
|
||
; Called by: PmgrOp
|
||
;
|
||
; Function: transfer data through modem
|
||
;————————————————————————————————————————————————————————————————————————————————
|
||
PrattModemOp
|
||
moveq #1,d1 ; set CC to not handled here
|
||
rts ; return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the Whitney registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveWhitney
|
||
MOVEA.L ASCBase,A2 ; point to the base of the ASC/Batman
|
||
MOVE.B ascMode(A2),-(SP) ; save the chip mode
|
||
MOVE.B ascVolControl(A2),-(SP) ; save the external sound volume control
|
||
MOVE.B ascPlayRecA(A2),-(SP) ; save channel A play/record register
|
||
MOVE.B bmIntControlA(A2),-(SP) ; save sound input control register a
|
||
MOVE.B bmIntControlB(A2),-(SP) ; save sound input control register b
|
||
MOVE.B wSndControl(A2),-(SP) ; save sound control regiser
|
||
MOVE.L wSndFIFOBase(A2),-(SP) ; save sound FIF0 Base address
|
||
MOVE.L wSndSingerCtl1(A2),-(SP) ; save Singer Control Register 1 & 2
|
||
MOVE.B WhitneyPwrCtl,-(SP) ; save Power Control Register
|
||
JMP (A1) ; and return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to Restore the Whitney registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreWhitney
|
||
MOVE.B (SP)+,WhitneyPwrCtl ; restore Power Control Register
|
||
MOVEA.L ASCBase,A2 ; point to the base of the ASC/Batman
|
||
MOVE.L (SP)+,wSndSingerCtl1(A2) ; restore Singer Control Register 1 & 2
|
||
MOVE.L (SP)+,wSndFIFOBase(A2) ; restore sound FIF0 Base address
|
||
MOVE.B (SP)+,wSndControl(A2) ; restore sound control regiser
|
||
MOVE.B (SP)+,bmIntControlB(A2) ; restore sound input control register b
|
||
MOVE.B (SP)+,bmIntControlA(A2) ; restore sound input control register a
|
||
MOVE.B (SP)+,ascPlayRecA(A2) ; restore channel A play/record register
|
||
MOVE.B (SP)+,ascVolControl(A2) ; restore the external sound volume control
|
||
MOVE.B (SP)+,ascMode(A2) ; restore the chip mode <K15>
|
||
JMP (A1) ; and return
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <K10>
|
||
; Routine: BlackbirdModemType
|
||
;
|
||
; Input:
|
||
;
|
||
; Outputs: d0.l has the modem Type
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: Returns type of modem installed in TIM Modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
BlackbirdModemType
|
||
move d0, d0 ; do something stupid for now so I can test this
|
||
rts
|
||
|
||
;_______________________________________________________________________________________ <K12>
|
||
; PrattPortAOn -- turns on serial port A
|
||
;
|
||
; Inputs:
|
||
; Outputs:
|
||
; Trashes:
|
||
; Notes: No need to do A -> C mapping. No need to Port B check (we don't have one).
|
||
;_______________________________________________________________________________________
|
||
PrattPortAOn
|
||
bset.b #SerPortAPwr,\
|
||
([PMgrBase],PmgrFlags2) ; log power state
|
||
bclr.b #WhitneySCCpwr,WhitneyPwrCtl ; turn on SCC driver chip
|
||
bclr.b #WhitneySCCclk,WhitneyPwrCtl ; start clock to SCC
|
||
rts
|
||
;_______________________________________________________________________________________ <K12> <K23>
|
||
; PrattPortAOff -- turns off serial port A
|
||
;
|
||
; Inputs:
|
||
; Outputs:
|
||
; Trashes:
|
||
;
|
||
; Notes: No need to do A -> C mapping. No need to Port B check (we don't have one).
|
||
; Disable interrupts so we don't get any by mistake on wake.
|
||
;_______________________________________________________________________________________
|
||
PrattPortAOff
|
||
bclr.b #SerPortAPwr,\
|
||
([PMgrBase],PmgrFlags2) ; log power state
|
||
move.l SCCRd, a0 ; Point to SCC
|
||
move.l SCCWr, a1
|
||
addq.l #2, a0 ; point to port A
|
||
addq.l #2, a1
|
||
move.b (a0), d0 ; sync up
|
||
move.b #9,(a1) ; write register 9
|
||
move.b #2,(a1) ; disable all SCC interrupts
|
||
bset.b #WhitneySCCpwr,WhitneyPwrCtl ; turn off SCC driver chip
|
||
bset.b #WhitneySCCclk,WhitneyPwrCtl ; stop clock to SCC
|
||
|
||
rts
|
||
|
||
;_______________________________________________________________________________________ <K12>
|
||
; PrattSonicOn -- turns on Sonic ethernet power
|
||
;
|
||
; Inputs:
|
||
; Outputs:
|
||
; Trashes: d2
|
||
;
|
||
;_______________________________________________________________________________________
|
||
PrattSonicOn
|
||
bset.b #EnetPwr,\
|
||
([PMgrBase],PmgrFlags3) ; log power state
|
||
bclr.b #WhitneyEnetPwr,WhitneyPwrCtl ; turn on power to Sonic
|
||
|
||
; wait for crystal to stabilize
|
||
move.w TimeVIAdb,d2 ; 1 ms delay
|
||
lsl.w #6,d2 ; 64 ms delay
|
||
@loop tst.b ([VIA])
|
||
dbra d2,@loop
|
||
|
||
bset.b #WhitneyEnetReset,WhitneyPwrCtl ; deassert _sleep pin <K17>
|
||
rts
|
||
;_______________________________________________________________________________________ <K12>
|
||
; PrattSonicOff -- turns off Sonic ethernet power
|
||
;
|
||
; Inputs:
|
||
; Outputs:
|
||
; Trashes:
|
||
;
|
||
;_______________________________________________________________________________________
|
||
PrattSonicOff
|
||
bclr.b #EnetPwr,\
|
||
([PMgrBase],PmgrFlags3) ; log power state
|
||
bclr.b #WhitneyEnetReset, WhitneyPwrCtl ; assert _sleep pin
|
||
bset.b #WhitneyEnetPwr,WhitneyPwrCtl ; turn off power to Sonic
|
||
rts
|
||
|
||
;_______________________________________________________________________________________ <K17>
|
||
; IsDriverInstalled -- looks to see if given driver is installed in the unit table
|
||
;
|
||
; Inputs: a0.l points to input driver name
|
||
; d1.l is the input driver name length
|
||
; Outputs: CCR has Z=0 for found, Z=1 for not found
|
||
; d0 = pointer to the DCE
|
||
; Trashes: d0
|
||
; Called by: Sleep Table code in Power Mgr
|
||
; Calls: .ENET driver _Open and _Control
|
||
;
|
||
;_______________________________________________________________________________________
|
||
IsDriverInstalled
|
||
@workregs REG a0-a3/d1-d4
|
||
movem.l @workregs, -(sp) ; save our working regs
|
||
|
||
MOVE.L UTableBase, A3 ; get address of the unit I/O table
|
||
MOVE.W UnitNtryCnt, D2 ; number of units to check
|
||
|
||
@CkInstLoop
|
||
MOVE.L (A3)+,D0 ; get next Device Control Entry handle
|
||
BEQ.S @nextEntry ; branch if no entry installed
|
||
MOVE.L D0,A2 ; DCE handle
|
||
MOVE.L (A2),D0 ; dereference handle
|
||
BEQ.S @nextEntry ; branch if null
|
||
MOVE.L D0,A1 ; A1 -> Device Control Entry
|
||
move.l d0, d4 ; save a pointer to the DCE
|
||
|
||
BTST #DRAMBased,DCtlFlags+1(A1) ; ROM-based?
|
||
MOVE.L DCtlDriver(A1), A1 ; driver ptr/handle
|
||
BEQ.S @1 ; br if ROM-based (A1 is a pointer)
|
||
MOVE.L A1, D0 ; be clean and check for 0 handle
|
||
BEQ.S @nextEntry ; skip if so
|
||
MOVE.L (A1), A1 ; deref handle
|
||
@1 MOVE.L A1, D0 ; is driver ptr nil?
|
||
BEQ.S @nextEntry ; br if so
|
||
|
||
LEA DrvrName(A1),A1 ; point A1 to driver name
|
||
MOVE.L D1, D0 ;
|
||
SWAP D0
|
||
MOVE.B (A1)+, D0 ; string 2 length
|
||
CMP.B D0, D1 ; are lengths the same?
|
||
BNE.S @nextEntry ; br if not (names shouldn't match if not)
|
||
_CmpString
|
||
BEQ @found ; found the driver!
|
||
|
||
@nextEntry SUBQ.W #1,D2 ; next unit table entry
|
||
BGT.S @CkInstLoop ; continue searching through all drivers
|
||
|
||
@found move.l d4, d0 ; return pointer to the DCE
|
||
bra.s @out ;
|
||
@notfound moveq #0, d0 ; driver not found
|
||
@out movem.l (sp)+, @workregs ; restore our working regs
|
||
rts
|
||
|
||
;_______________________________________________________________________________________ <K17>
|
||
; IsDriverOpen -- looks at driver flags in DCE to see if driver is open
|
||
;
|
||
; Inputs: d0 points to driver
|
||
; Outputs: CCR has Z=0 for open, Z=1 for not open
|
||
; d0 = pointer to the DCE
|
||
; Trashes: d0
|
||
; Called by: Sleep Table code in Power Mgr
|
||
; Calls: .ENET driver _Open and _Control
|
||
;
|
||
;_______________________________________________________________________________________
|
||
IsDriverOpen
|
||
@workregs REG a0-a3/d1-d4
|
||
movem.l @workregs, -(sp) ; save our working regs
|
||
|
||
movea.l d0, a0 ; point to the driver
|
||
move.w dCtlFlags(a0), d0 ; get driver flags
|
||
btst #5, d0 ; is the driver Open?
|
||
beq.s @notopen ; nope
|
||
|
||
@open moveq #1, d0 ; driver open
|
||
bra.s @out
|
||
@notopen moveq #0, d0 ; driver not open
|
||
@out movem.l (sp)+, @workregs ; restore our working regs
|
||
rts
|
||
|
||
;_______________________________________________________________________________________ <K17>
|
||
; EnetSleep/EnetWake -- Calls .ENET driver to sleep or wake SONIC
|
||
;
|
||
; Inputs: a1 points to return address
|
||
; Outputs: none
|
||
; Trashes: none
|
||
; Called by: Sleep Table code in Power Mgr
|
||
; Calls: .ENET driver _Open and _Control
|
||
;
|
||
;_______________________________________________________________________________________
|
||
ESleep EQU 254 ; Sleep the SONIC
|
||
EWake EQU 255 ; Wake the SONIC
|
||
EDetachPH EQU 248 ; Detach the protocol handler
|
||
|
||
EnetSleep
|
||
move.l #ESleep, d0 ; We're sleeping now
|
||
bra.s EnetWakeSleep
|
||
EnetWake
|
||
move.l #Ewake, d0 ; We're waking now
|
||
|
||
EnetWakeSleep
|
||
@workregs REG a0-a2/d1-d2
|
||
MOVEM.L @workregs,-(SP) ; save some reg's
|
||
move.l d0, d2 ; save our request
|
||
|
||
TestFor SONICExists ; do we have a SONIC?
|
||
beq.s @out ; no SONIC
|
||
lea EnetName, a0 ; point to driver name
|
||
moveq.l #0,d1
|
||
move.b (a0)+, d1 ; get the driver name length
|
||
bsr.w IsDriverInstalled ; is the .ENET driver installed?
|
||
beq.s @out ; driver not installed
|
||
bsr.w IsDriverOpen ; is the .ENET driver open?
|
||
beq.s @out ; driver not open
|
||
|
||
moveq #ioQElSize, d0 ; size the io stack frame
|
||
sub.w d0,sp ; Allocate IO stack frame
|
||
asr.w #1, d0 ; number of words in frame
|
||
subi.w #1, d0 ; our friend dbra
|
||
move.l sp, a2 ; point to start of frame
|
||
@clr clr.w (a2)+ ; clear frame
|
||
dbra d0, @clr
|
||
|
||
MOVE.L SP,A0 ; Save this place
|
||
LEA EnetName,A2 ; Get Ethernet refnum
|
||
MOVE.L A2,ioVNPtr(A0)
|
||
MOVE.B #fsCurPerm,ioPermssn(A0)
|
||
_Open
|
||
MOVE.w d2,csCode(A0) ; Sleep/Wake the Sonic
|
||
_Control ; (synchronously)
|
||
|
||
; MOVE #EDetachPH,CSCode(A0); Set code for detach PH
|
||
; MOVE #0,EProtType(A0) ; Set for 802.2
|
||
; _Control ; (synchronously)
|
||
|
||
add.w #ioQElSize,SP ; Allocate IO stack frame
|
||
|
||
@out movem.l (sp)+, @workregs ; restore the registers
|
||
JMP (A1) ; and return
|
||
|
||
|
||
EnetName dc.b 5 ; length of '.ENET'
|
||
dc.b '.ENET' ; driver name
|
||
|
||
|
||
;••••••••••••••••••••••••••••••••••••• Dispatch Tables ••••••••••••••••••••••••••••••••••••••••
|
||
|
||
IMPORT BasePRAM;••
|
||
IMPORT CPUSpeed;••
|
||
IMPORT ExternaVideoOnproc;••
|
||
IMPORT IdleDelay;••
|
||
IMPORT IdleDisable;••
|
||
IMPORT IdleEnable;••
|
||
IMPORT IdleMind
|
||
IMPORT IdleRead
|
||
IMPORT IdleState
|
||
IMPORT IdleUpdate;••
|
||
IMPORT IdleUpdateTrap;••
|
||
IMPORT ModemStatusRT ;••
|
||
IMPORT ModemTypeProc ;••
|
||
IMPORT PmgrTrap
|
||
IMPORT PowerMgrHook
|
||
IMPORT PDimScreens
|
||
IMPORT ScaledBattery
|
||
IMPORT ScsiDiskModeproc;••
|
||
IMPORT SecondaryInitproc
|
||
IMPORT SerialPower;••
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (PwrDispatchEnd-PwrDispatchVects) ; number of table entries
|
||
PwrDispatchVects
|
||
DC.L PmgrTrap-PwrDispatchVects ; Selector #0
|
||
DC.L IdleUpdate-PwrDispatchVects ; Selector #1
|
||
DC.L IdleDelay-PwrDispatchVects ; Selector #2
|
||
DC.L IdleMind-PwrDispatchVects ; Selector #3
|
||
DC.L IdleRead-PwrDispatchVects ; Selector #4
|
||
DC.L IdleEnable-PwrDispatchVects ; Selector #5
|
||
DC.L IdleDisable-PwrDispatchVects ; Selector #6
|
||
DC.L CPUSpeed-PwrDispatchVects ; Selector #7
|
||
DC.L BasePRAM-PwrDispatchVects ; Selector #8
|
||
DC.L ScaledBattery-PwrDispatchVects ; Selector #9
|
||
DC.L PowerMgrHook-PwrDispatchVects ; Selector #10
|
||
DC.L PDimScreens-PwrDispatchVects ; Selector #11
|
||
DC.L 0 ; Selector #12 (FactoryDisp patched on disk)
|
||
DC.L PrivateFeatures-PwrDispatchVects ; Selector #13
|
||
PwrDispatchEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (PMgrHookEnd-PMgrHookVects) ; number of table entries
|
||
PMgrHookVects
|
||
DC.L SecondaryInitproc-PMgrHookVects ; Selector #0
|
||
DC.L ScsiDiskModeproc-PMgrHookVects ; Selector #1
|
||
DC.L ExternaVideoOnproc-PMgrHookVects ; Selector #2
|
||
DC.L ModemTypeProc-PMgrHookVects ; Selector #3
|
||
PMgrHookEnd
|
||
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (PMgrOpTblEnd-PMgrOpTbl) ; number of table entries
|
||
PMgrOpTbl
|
||
DC.L PmgrTrap-PMgrOpTbl ; Pmgr Trap #A085
|
||
DC.L IdleUpdateTrap-PMgrOpTbl ; Pmgr Trap #A285
|
||
DC.L IdleState-PMgrOpTbl ; Pmgr Trap #A485
|
||
DC.L SerialPower-PMgrOpTbl ; Pmgr Trap #A685
|
||
PMgrOpTblEnd
|
||
|
||
|
||
;••••••••••••••••••••••••••••••••••••••• Sound VBL •••••••••••••••••••••••••••••••••••••••
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: SndWatch
|
||
;
|
||
; Inputs: A0 - pointer to VBL task queue element
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0-D1, A0
|
||
;
|
||
; Function: A VBL task called once every ten seconds that checks the sound latch for
|
||
; ASC new use. If so then sound power is turned on. If power is already on
|
||
; then then the latch is cleared. If the latch stays clear for two VBLs then
|
||
; sound power is turned off.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SndWatch ;MOVE.L PmgrBase,A2
|
||
;LEA SwVBLTask(A2),A0 ; Get pointer to vbl task
|
||
MOVE.W #SndWFreq,vblCount(A0) ; reset the counter
|
||
|
||
CLR.W -(SP) ; allocate a buffer on the stack
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #SoundRead,-(SP) ; pmCommand = get sound latch state
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
|
||
MOVE.B (SP)+,D0 ; get the sound state
|
||
BEQ.S @NoSound ; -> no sound activity
|
||
|
||
MOVEQ #sndOnclrLtch,D1 ; assume the latch is set (turn sound on, clear latch)
|
||
BTST #1,D0 ; is the latch set?
|
||
BNE.S @SndActive ; -> yes
|
||
|
||
MOVEA.L PMgrBase,A0 ; no, sound's been on but now it's not
|
||
TST.B SysTaskFlag(A0) ; are the sound input primitives set up?
|
||
BEQ.S @NoInputs ; -> no, there can't be a sound input source selected
|
||
|
||
jsrTBL sndInputSource ; is a sound source selected?
|
||
TST.B D0
|
||
BNE.S @NoSound ; -> yes, sound input is active so don't power off sound
|
||
|
||
@NoInputs MOVEQ #soundOff,D1 ; nothing's on so turn sound off
|
||
@SndActive MOVE.B D1,-(SP) ; put the new sound state into a buffer
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
MOVE.W #1,-(SP) ; pmLength = 1
|
||
MOVE.W #SoundSet,-(SP) ; pmCommand = set sound state
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4+2(SP),SP ; toss the parameter block and buffer
|
||
|
||
TST.B D1 ; is sound turned off?
|
||
BEQ.S @NoSound ; -> yes
|
||
_IdleUpdateDispatch
|
||
@NoSound RTS ; all done
|
||
|
||
|
||
|
||
;••••••••••••••••••••••••••••••••••••••• IdleMind ••••••••••••••••••••••••••••••••••••••••
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: RunIdleRoutinesProc (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0-D2, A0 (must preserve A1)
|
||
;
|
||
; Function: Runs IdleMind routines which are not based on LastAct. These routines
|
||
; have priority over the LastAct based ones with the exception of the
|
||
; countdown timers.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RunIdleRoutinesProc
|
||
BSR.S ChkDimming ; is it time to Power Down the Screen
|
||
BSR.S ChkHdSpinDown ; Is it time to Power Down the HD
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: ChkDimming
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0-D2, A0 (must preserve A1)
|
||
;
|
||
; Function: Runs IdleMind routines which are not based on LastAct. These routines
|
||
; have priority over the LastAct based ones with the exception of the
|
||
; countdown timers.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
ChkDimming
|
||
TST.B DimmingDisable(A2) ; IF counting semaphor = 0 THEN
|
||
BNE.S @Exit ;
|
||
|
||
BSR CurFrontProcEqual ; IF Process are the same THEN
|
||
BEQ.S @Exit ;
|
||
|
||
MOVE.L Ticks,D0 ; D0 = Current time
|
||
SUB.L LastUsrAct(A2),D0 ; Calc elapsed time since last user activity
|
||
BMI.S @hadActivityNoDim ; IF LastUsrAct > Tick THEN exit
|
||
MOVEQ #0,D1 ; Clear register
|
||
CMP.L DimmingWaitTime(A2),D0 ; IF TimeToWait <= TimeSinceLastAct THEN
|
||
BLO.S @hadActivityNoDim ;
|
||
BSET #PmgrDimStatus,PmgrFlags2(A2) ; Set the flag that we are dimmed
|
||
BNE.S @Exit ; IF not already dimmed THEN
|
||
MOVEQ #1,D0 ; Set Video for Power Down
|
||
BRA VidLowPwrSelect ; Set Video State
|
||
@hadActivityNoDim ; ELSE
|
||
BCLR #PmgrDimStatus,PmgrFlags2(A2) ; Clear the flag that we are dimmed
|
||
BEQ.S @Exit ; IF dimmed THEN
|
||
MOVEQ #0,D0 ; Set Video for Power Up
|
||
BRA VidLowPwrSelect ; Set Video State
|
||
@Exit ; ENDIF
|
||
RTS ; ENDIF
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: CheckCountDownTimer (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: CCR - BEQ = not in countdown mode, BNE = go to sleep
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: returns whether or not we're in a countdown condition
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
CheckCountDownTimer
|
||
CMP.B #4,LastLevel(A2) ; Test for level 4 sleep
|
||
BNE.S @NotCountingDown ; IF LastLevel != 4 THEN exit
|
||
CMP.B #SleepWait,Level4Cnt(A2) ; Test for standing 10 count
|
||
BLS.S @NotCountingDown ; IF Level4Cnt != 10 THEN exit
|
||
|
||
BSET #LowPowerSleep,PMgrFlags2(A2) ; set the low power sleep flag <H27>
|
||
MOVEQ #-1,D0 ; Set to force sleep
|
||
RTS ; Goodnight
|
||
|
||
@NotCountingDown
|
||
MOVEQ #0,D0 ; Set condition codes
|
||
RTS ; exit
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: ChkHdSpinDown (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0-D2, A0 (must preserve A1)
|
||
;
|
||
; Function: determines whether to spin down the hard drive. If so, then jumps through
|
||
; a vector to spin down the hard drive
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
ChkHdSpinDown
|
||
MOVE.L LastHd(A2),D2 ; Get last HD activity
|
||
BEQ.S @Done ; IF DriveSpunDown THEN exit
|
||
|
||
MOVE.L HDvector(A2),D0 ; IF HDvector = null THEN <H15>
|
||
BEQ.S @Done ; exit
|
||
|
||
BTST #dockingStation,dockFlags(A2) ; are we in a docking station? <H15>
|
||
BNE.S @Done ; -> yes, never spin down the hard disk <H15>
|
||
|
||
BTST.B #HasCharger,Charger(A2) ; Check for Battery
|
||
BEQ.S @OnBattery ; IF !HasCharger THEN On Battery
|
||
|
||
BTST.B #ChargeSleep,SleepFlags(A2) ; Check if in ChargeSleep since no spin down while charging
|
||
BNE.S @Done ; IF ChargeSleep THEN exit
|
||
|
||
@OnBattery MOVEA.L D0,A0 ; get the spin down routine vector <H15>
|
||
MOVEQ #0,D0
|
||
MOVE.B HDTime(A2),D0 ; Get current HD timeout
|
||
BNE.S @hdTOok ; IF HDTime = null THEN
|
||
MOVE.B #DfltHDTime,D0 ; Set Default
|
||
@hdTOok MULU.W #pram2ticks,D0 ; Convert HD time out to ticks
|
||
MOVE.L Ticks,D1 ; Get current time
|
||
SUB.L D2,D1 ; D1 = elapsed time since last HD activity
|
||
CMP.L D1,D0 ; Check for HD timeout
|
||
BGT.S @Done ; IF elapsedTime > TimeOut THEN
|
||
JSR (A0) ; Call spin down routine
|
||
@Done RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: ChkSleepTimeOut (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: CCR - BEQ = continue, BNE = request sleep
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: returns whether to issue a sleep request
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
ChkSleepTimeOut
|
||
BTST.B #HasCharger,Charger(A2) ; Check for Battery
|
||
BEQ.S @OnBattery ; IF !HasCharger THEN On Battery
|
||
|
||
BTST.B #ChargeSleep,SleepFlags(A2) ; Check if in ChargeSleep since no spin down while charging
|
||
BNE.S @Done ; IF ChargeSleep THEN exit
|
||
|
||
@OnBattery MOVEQ #0,D0
|
||
MOVE.B SleepTime(A2),D0 ; Get current Sleep timeout
|
||
BNE.S @slpTOok ; IF SleepTime = null THEN
|
||
MOVE.B #DfltSlpTime,D0 ; Set Default
|
||
@slpTOok MULU.W #pram2ticks,D0 ; Convert Sleep timeout to ticks
|
||
ADD.L LastAct(A2),D0 ; Calc time to go to sleep
|
||
CMP.L Ticks,D0 ; IF TimeToSleep >= CurrentTime THEN
|
||
BGE.S @Done ; exit
|
||
|
||
TST.B AutoSlpDisable(A2) ; IF counting semaphor > 0 THEN
|
||
BGT.S @Done ; exit
|
||
|
||
BSR CurFrontProcEqual ; IF Processes <> THEN
|
||
BEQ.S @Done ; exit
|
||
|
||
MOVEQ #-1,D0 ; Set a sleep request
|
||
RTS ; Try to Sleep
|
||
|
||
@Done MOVEQ #0,D0 ; Set condition codes
|
||
RTS ; Return
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: ChkIdle (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: CCR - BEQ = continue, BNE = go idle
|
||
;
|
||
; Trashes: D0-D1
|
||
;
|
||
; Function: determines whether or not we're in idle
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
ChkIdle
|
||
BTST #dockNoPowerCycle,dockFlags(A2) ; is power cycling allowed? <H5>
|
||
BNE.S @hadActivity ; -> no, bail <H5>
|
||
|
||
TST.B MBState ; IF mouse down THEN
|
||
BEQ.S @UpdateOut ; Update Activity and Exit
|
||
|
||
TST.B watchCrsr(A2) ; IF watchCrsr THEN
|
||
BNE.S @UpdateOut ; Update Activity and Exit
|
||
|
||
BTST.B #IdleBit,SleepFlags(A2) ; IF idleDisable THEN
|
||
BNE.S @hadActivity ; Exit and set Activity
|
||
|
||
TST.B IdleFlagCnt(A2) ; IF IdleFlagCnt THEN
|
||
BGT.S @hadActivity ; Exit and set Activity
|
||
|
||
MOVE.L Ticks,D0 ; Mouse activity woke us up
|
||
SUB.L LastAct(A2),D0 ; Calc elapsed time since last activity
|
||
BMI.S @hadActivity ; IF LastAct > Tick THEN exit
|
||
MOVEQ #0,D1 ; Clear register
|
||
MOVE.W PwrCycWaitTime(A2),D1 ; Get the time to wait
|
||
CMP.L D0,D1 ; IF TimeToWait >= TimeSinceLastAct THEN
|
||
BGE.S @hadActivity ; Exit
|
||
@noActivity
|
||
MOVEQ #-1,D0 ; Set condition codes
|
||
RTS
|
||
@UpdateOut
|
||
MOVE.L Ticks,LastAct(A2) ; Update activity
|
||
@hadActivity
|
||
MOVEQ #0,D0 ; Set condition codes
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: CalcProgressive (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: D1 - power cycling count
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: calculates the number of power cycles we will follow through
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
CalcProgressive
|
||
MOVE.W PwrCycCounter(A2),D1 ; Power cycle a limited number of times
|
||
MOVE.L LastAct(A2),D0 ; D0 = LastAct
|
||
CMP.L PMgrScratch.ProgLastAct(A2),D0 ; Check for no activity
|
||
BNE.S @SomeAct ; Some Activity. Branch.
|
||
MOVE.W PMgrScratch.ProgCounter(A2),D1 ; Get current power cycle counter
|
||
ADD.W PwrCycProgGrow(A2),D1 ; Increment counter
|
||
CMP.W PwrCycProgMax(A2),D1 ; Set power cycle number to new value
|
||
BHS.S @SetMax ; Have we reached maximum value
|
||
|
||
MOVE.W D1,PMgrScratch.ProgCounter(A2) ; Save it for next time
|
||
RTS
|
||
|
||
@SetMax MOVE.W PwrCycProgMax(A2),D1 ; Set power cycling count to maximum level
|
||
RTS
|
||
|
||
@SomeAct MOVE.L D0,PMgrScratch.ProgLastAct(A2) ; Reset Activity for next check
|
||
MOVE.W D1,PMgrScratch.ProgCounter(A2) ; Reset counter
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: GoPowerCycle (IdleMind)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager variables
|
||
;
|
||
; Outputs: CCR - BEQ = continue, BNE = go idle
|
||
;
|
||
; Trashes: D0-D1
|
||
;
|
||
; Function: high-level power cycling call
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
GoPowerCycle
|
||
BSR.L SetSupervisorMode ; Set the machine to supervisor mode
|
||
MOVE.W D0,SaveCPUState.CPUSRsave(A2) ; Save the the SR
|
||
MOVE.L AutoInt7,SaveCPUState.CPUNMIsave(A2); Save the NMI Vector
|
||
MOVE.L ResetSP,-(SP) ; save current ResetSP
|
||
MOVE.L ResetPC,-(SP) ; save current ResetPC
|
||
BTST.B #hwCbFPU,HWCfgFlags ; Do we have an FPU?
|
||
BEQ.S @docycle ; IF hasFPU THEN
|
||
FMOVEM.L FPCR/FPSR/FPIAR,-(SP) ; Save them regs
|
||
FMOVEM.X FP0-FP7,-(SP) ; Save more them regs
|
||
@docycle MOVE.L LastAct(A2),-(SP) ; Save lastact as an activity flag
|
||
MOVE.L PwrCycProc(A2),A0 ; Get pointer to power cycling routine
|
||
JSR (A0) ; Go power cycle
|
||
MOVE.L (SP)+,D0 ; Get the previous lastact
|
||
CMP.L LastAct(A2),D0 ; Test for any activity
|
||
DBNE D1,@docycle ; Go through another loop if none
|
||
|
||
BTST.B #hwCbFPU,HWCfgFlags ; Do we have an FPU?
|
||
BEQ.S @noFPU ; IF hasFPU THEN
|
||
FMOVEM.X (SP)+,FP0-FP7 ; Restore more them regs
|
||
FMOVEM.L (SP)+,FPCR/FPSR/FPIAR ; Restore them regs
|
||
@noFPU MOVE.L (SP)+,ResetPC ; Restore the ResetPC
|
||
MOVE.L (SP)+,ResetSP ; Restore the ResetSP
|
||
MOVE.W SaveCPUState.CPUSRsave(A2),SR ; Restore the Status Register from power cycle
|
||
MOVE.L SaveCPUState.CPUNMIsave(A2),AutoInt7; Restore the NMI Vector
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: CurFrontProcEqual
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: CCR - BEQ = Processes Not Equal, BNE = Processes Equal
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: returns whether the process managers front and current process are the same.
|
||
; This is important since we can neither sleep nor dim if they are different.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
CurFrontEqFrame RECORD 0,DECR
|
||
FrontSerialNum DS.B ProcessSerialNumber
|
||
CurSerialNum DS.B ProcessSerialNumber
|
||
Result DS.W 1
|
||
CurFrontEqFrameSz EQU *
|
||
ENDR
|
||
|
||
CurFrontProcEqual
|
||
CurFrontProcRegs REG A0-A1
|
||
WITH CurFrontEqFrame
|
||
LINK A6,#CurFrontEqFrameSz ; Build StackFrame
|
||
MOVEM.L CurFrontProcRegs,-(SP) ; Save them regs
|
||
SUBQ.W #2,SP ; Make space for OSErr
|
||
PEA CurSerialNum(A6) ; Set pointer to CurSerialNum
|
||
_GetCurrentProcess ; Get Process Managers Current Process
|
||
PEA FrontSerialNum(A6) ; Set pointer to FrontSerialNum
|
||
_GetFrontProcess ; Get Process Managers Front Process
|
||
TST.W (SP) ; IF Error THEN
|
||
BNE.S @ProcessEqual ; NoFrontProcesses Exit, Assume ProcessEqual
|
||
|
||
PEA CurSerialNum(A6) ; Set pointer to CurSerialNum
|
||
PEA FrontSerialNum(A6) ; Set pointer to FrontSerialNum
|
||
PEA Result(A6) ; Set pointer to result
|
||
_SameProcess ; IF CurrentProcess = FrontProcess THEN
|
||
TST.W (SP) ; IF Err THEN
|
||
BNE.S @ProcessNotEqual ; ProcessNotEqual
|
||
TST.B Result(A6) ; ELSE
|
||
BEQ.S @ProcessNotEqual ; ProcessEqual
|
||
@ProcessEqual
|
||
MOVEQ #1,D0 ; Set condition codes for Processes Equal
|
||
BRA.S @Exit ; That's all folks
|
||
@ProcessNotEqual
|
||
MOVEQ #0,D0 ; Set condition codes for no sleep
|
||
@Exit
|
||
ADDQ.W #2,SP ; Clean up the stack
|
||
MOVEM.L (SP)+,CurFrontProcRegs ; Restore them regs
|
||
UNLK A6 ; Release stack fram
|
||
TST.L D0 ; Set Condition codes
|
||
RTS ; <5>
|
||
|
||
;••••••••••••••••••••••••••••••••••••••• PowerCycling •••••••••••••••••••••••••••••••••••••••
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
;
|
||
; PowerCycle
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
PowerCycleRegs REG D0-D7/A0-A6
|
||
|
||
WITH CPUStateRec
|
||
|
||
;———————————————————————————————————————————————————————————————————————
|
||
MACHINE MC68040
|
||
PowerCycle040
|
||
@SaveSetRegs REG D0-D7/A3-A6
|
||
MOVE.W SR,-(SP) ; Save status register
|
||
ORI.W #HiIntMask,SR ; No more interrupts
|
||
MOVEM.L PowerCycleRegs,-(SP) ; save them registers
|
||
MOVE.L PMgrBase,A2 ; get pointer to globals
|
||
LEA SaveCPUState(A2),A1 ; get pointer to SaveCPUState area
|
||
|
||
MOVEC CACR,D7 ; get current Cache Register
|
||
MOVEQ #0,D0 ; clear register
|
||
MOVEC D0,CACR ; disable caches
|
||
CPUSHA bc ; flush both caches entirely
|
||
|
||
|
||
; Get CPU Internal State Registers
|
||
MOVEC URP,D0 ; Save User Root Pointer
|
||
MOVEC SRP,D1 ; Save Supervisor Root Pointer
|
||
MOVEC TC,D2 ; Save TC
|
||
MOVEC DTT0,D3 ; Save Data TT0
|
||
MOVEC DTT1,D4 ; Save Data TT1
|
||
MOVEC ITT0,D5 ; Save Instruction TT0
|
||
MOVEC ITT1,D6 ; Save Instruction TT1
|
||
|
||
MOVEC VBR,A3 ; Save vector base reg
|
||
MOVE.L AutoInt7(A3),-(SP) ; Save the NMI Vector
|
||
MOVEC USP,A4 ; Save User Stack Pointer
|
||
MOVEC MSP,A5 ; Save Master Stack Pointer
|
||
MOVEC ISP,A6 ; Save Interrupt Stack Pointer
|
||
|
||
MOVEM.L @SaveSetRegs,(A1) ; Save all them special regs
|
||
|
||
; Last Chance for SCC
|
||
MOVEQ #(1<<SerPortAPwr)+\
|
||
(1<<SerPortBPwr),D1 ; IF SCC_Pwr THEN
|
||
AND.B PmgrFlags2(A2),D1 ; SCC may have data
|
||
BEQ.S @NoSCC ; ELSE branch
|
||
|
||
BTST #0,([SccRd]) ; IF SCC has Data THEN
|
||
BNE.S @DontCycle ; Don't kill the power
|
||
|
||
@NoSCC
|
||
MOVE.L PwrCycRestore(A2),\
|
||
AutoInt7(A3) ; Set NMIVec to our PwrCycling NMI handler
|
||
MOVE.L PwrCycRestore(A2),\
|
||
ResetPC ; Set the PC to restore code when coming up
|
||
MOVE.L A1,ResetSP ; Save it in ResetSP for powering up
|
||
|
||
; Kill Power
|
||
MOVE.L PowerCycleReg(A2),A0 ; Get pointer to Pratt Nap mode register
|
||
MOVE.B PwrCycRegValue(A2),(A0) ; set the magic value <K22>
|
||
BRA.S * ; Wait for the drugs to take effect
|
||
|
||
@DontCycle
|
||
MOVEC D0,CACR ; restore them caches
|
||
ADDQ.W #4,SP ; clear the NMI from the stack
|
||
MOVEM.L (SP)+,PowerCycleRegs ; Restore them regs
|
||
MOVE.W (SP)+,SR
|
||
RTS
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
MACHINE MC68030
|
||
PowerCycle030
|
||
MOVE.W SR,-(SP)
|
||
OR.W #HiIntMask,SR ; No more interrupts
|
||
|
||
MOVEM.L PowerCycleRegs,-(SP) ; save all for now, Save only the important registers
|
||
|
||
MOVEC CACR,D0 ; Now save cache regs
|
||
OR.W #(1<<11)+(1<<3),D0 ; Flush caches upon return
|
||
MOVEC CAAR,D1 ;
|
||
MOVEC VBR,A0 ; Also save vector base
|
||
MOVE.L USP,A1 ; and alternats stack pointers
|
||
MOVEC MSP,A2 ; .
|
||
|
||
MOVEM.L D0/D1/A0-A2,-(SP) ; Save some cool registers
|
||
|
||
MOVEQ #0,D0
|
||
MOVEC D0,VBR ; need to put return addr right at the start
|
||
|
||
MOVE.L PmgrBase,A1 ; get pmgr locals
|
||
MOVEA.L PowerCycleReg(A1),A2 ; Get powercycling register in A2 <H29>
|
||
|
||
MOVE.L PwrCycRestore(A1),ResetPC; Set the PC to restore code when coming up
|
||
|
||
MOVE.L SP,SaveCPUState.CPUISPsave(A1) ; save old SP
|
||
PMOVE TC,SaveCPUState.CPUMMUTCsave(A1); Save TC
|
||
PMOVE CRP,SaveCPUState.CPUMMUCRPsave(A1) ; Save CRP
|
||
PMOVE TT1,SaveCPUState.CPUMMUTT1save(A1) ; Save TT1
|
||
PMOVE TT0,SaveCPUState.CPUMMUTT0save(A1) ; Save TT2
|
||
|
||
MOVE.L PmgrVarPhysPtr(A1),A3 ; Get the physical address of the PMgr Globasl <25> HJR
|
||
LEA SaveCPUState(A3),A3 ; PwrCycGlobals-4 Byte below must be free for NMIStkFrm <25> HJR
|
||
MOVE.L A3,ResetSP ; Save it in ResetSP for powering up <25> HJR
|
||
MOVE.L PwrCycRestore(A1),AutoInt7 ; Set NMIVec to our PwrCycling NMI handler <24> HJR
|
||
|
||
MOVE.L SccRd,A3 ; SCC may have data to get
|
||
BTST #0,(A3) ; Is there any SCC Data
|
||
BNE.S @DontCycle ; Yes.. Forget killing the power
|
||
|
||
MOVE.L D0,([RomBase]) ; Clear the Bus. Yes I Know it's in ROM... <6> HJR
|
||
MOVE.L D0,(A2) ; Pull the pin <6> HJR
|
||
BRA.S * ; Wait for the drugs to take effect
|
||
|
||
@DontCycle MOVEC A0,VBR ; Restore the VBR <37> HJR
|
||
MOVE.L SaveCPUState.\
|
||
CPUNMIsave(A1),AutoInt7 ; Restore the NMI Vector <33> HJR
|
||
ADDA.L #5*4,SP ; Restore stack state
|
||
MOVEM.L (SP)+,PowerCycleRegs ; Restore them regs
|
||
MOVE.W (SP)+,SR
|
||
RTS
|
||
|
||
;———————————————————————————————————————————————————————————————————————
|
||
PowerCycle020
|
||
MOVE.W SR,-(SP)
|
||
OR.W #HiIntMask,SR ; No more interrupts
|
||
|
||
MOVEM.L PowerCycleRegs,-(SP) ; save all for now, Save only the important registers
|
||
|
||
MOVEC CACR,D0 ; Now save cache regs
|
||
OR.W #(1<<11)+(1<<3),D0 ; Flush caches upon return
|
||
MOVEC CAAR,D1 ;
|
||
MOVEC VBR,A0 ; Also save vector base
|
||
MOVE.L USP,A1 ; and alternats stack pointers
|
||
MOVEC MSP,A2 ; .
|
||
|
||
MOVEM.L D0/D1/A0-A2,-(SP) ; Save some cool registers
|
||
|
||
MOVEQ #0,D0
|
||
MOVEC D0,VBR ; need to put return addr right at the start
|
||
|
||
MOVE.L PmgrBase,A1 ; get pmgr locals
|
||
MOVEA.L PowerCycleReg(A1),A2 ; Get powercycling register in A1 <H29>
|
||
|
||
MOVE.L PwrCycRestore(A1),ResetPC; Set the PC to restore code when coming up
|
||
MOVE.L SP,ResetSP ; Save the stack pointer in ResetSP for power up
|
||
MOVE.L PwrCycRestore(A1),AutoInt7; Set NMIVec to our PwrCycling NMI handler <24> HJR
|
||
|
||
MOVE.L SccRd,A3 ; SCC may have data to get
|
||
BTST #0,(A3) ; Is there any SCC Data
|
||
BNE.S @DontCycle ; Yes.. Forget killing the power
|
||
|
||
MOVE.L D0,([RomBase]) ; Clear the Bus. Yes I Know it's in ROM... <6> HJR
|
||
MOVE.L D0,(A2) ; Pull the pin <6> HJR
|
||
BRA.S * ; Wait for the drugs to take effect
|
||
|
||
@DontCycle
|
||
MOVEC A0,VBR ; Restore the VBR <37> HJR
|
||
MOVE.L SaveCPUState.\
|
||
CPUNMIsave(A1),AutoInt7 ; Restore the NMI Vector <33> HJR
|
||
ADDA.L #5*4,SP ; Restore stack state
|
||
MOVEM.L (SP)+,PowerCycleRegs ; Restore them regs
|
||
MOVE.W (SP)+,SR
|
||
RTS
|
||
|
||
;———————————————————————————————————————————————————————————————————————
|
||
MACHINE MC68040
|
||
Restore040
|
||
@SaveSetRegs REG D0-D7/A3-A6
|
||
MOVEM.L (SP),@SaveSetRegs ; get some saved special regs
|
||
MOVEC D0,URP ; restore User Root Pointer
|
||
MOVEC D1,SRP ; restore Supervisor Root Pointer
|
||
MOVEC D3,DTT0 ; restore Data TT0
|
||
MOVEC D4,DTT1 ; restore Data TT1
|
||
MOVEC D5,ITT0 ; restore Instruction TT0
|
||
MOVEC D6,ITT1 ; restore Instruction TT1
|
||
MOVEC A3,VBR ; restore VBR
|
||
MOVEC A4,USP ; restore User Stack pointer
|
||
MOVEC A5,MSP ; restore Master Stack pointer
|
||
MOVEC A6,ISP ; restore Interrupt Stack pointer
|
||
|
||
PFLUSHA ; flush ATC
|
||
MOVEC D2,TC ; restore TC
|
||
|
||
CINVA BC ; invalidate both caches
|
||
MOVEC D7,CACR ; Restore Vital CPU registers
|
||
MOVE.L (SP)+,AutoInt7(A3) ; Restore the NMI Vector
|
||
MOVEM.L (SP)+,PowerCycleRegs ; Restore them regs
|
||
MOVE.W (SP)+,SR
|
||
RTS
|
||
|
||
;———————————————————————————————————————————————————————————————————————
|
||
MACHINE MC68030
|
||
Restore030
|
||
MOVE.L ResetSP,A0 ; Save the Power Manager globals in the stack <25> HJR
|
||
|
||
MOVE.L CPUISPsave(A0),SP ; Restore the stack to the previous life
|
||
PMOVE CPUMMUTT0save(A0),TT0 ; "Pop" the MMU regs of the video stack
|
||
PMOVE CPUMMUTT1save(A0),TT1
|
||
PMOVE CPUMMUCRPsave(A0),CRP
|
||
PMOVE CPUMMUTCsave(A0),TC ; MMU is now restored, we have memory
|
||
|
||
MOVEM.L (SP)+,D0/D1/A0-A2
|
||
|
||
MOVEC D0,CACR ; Restore Vital CPU registers
|
||
MOVEC D1,CAAR
|
||
MOVEC A0,VBR
|
||
MOVEC A1,USP
|
||
MOVEC A2,MSP
|
||
|
||
MOVE.L PMgrBase,A0 ; Get the Globals <24> HJR
|
||
MOVE.L SaveCPUState.\
|
||
CPUNMIsave(A0),AutoInt7 ; Restore the NMI Vector <24> HJR
|
||
|
||
MOVEM.L (SP)+,PowerCycleRegs ; Restore them regs
|
||
MOVE.W (SP)+,SR
|
||
RTS
|
||
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————
|
||
Restore020
|
||
MOVEM.L (SP)+,D0/D1/A0-A2 ; restore cool registers
|
||
MOVEC D0,CACR ; Restore Vital CPU registers
|
||
MOVEC D1,CAAR
|
||
MOVEC A0,VBR
|
||
MOVE.L A1,USP
|
||
MOVEC A2,MSP
|
||
|
||
MOVE.L PMgrBase,A0 ; Get the Globals <25> HJR
|
||
MOVE.L SaveCPUState.\
|
||
CPUNMIsave(A0),AutoInt7 ; Restore the NMI Vector <25> HJR
|
||
|
||
MOVEM.L (SP)+,PowerCycleRegs ; Restore them regs
|
||
MOVE.W (SP)+,SR
|
||
RTS
|
||
|
||
ENDWITH
|
||
|
||
;•••••••••••••••••••••••••••••••••••••••• Sleep ••••••••••••••••••••••••••••••••••••••••••
|
||
;
|
||
; The following are a set of possible routines that are used to save the state, or
|
||
; set necessary conditions in order for the machine to sleep. For each machine there
|
||
; is a corresponding table of entries which point to the necessary routines. The
|
||
; register convention is that A0/A1 must be PRESERVED throughout all routines. All
|
||
; other register can be trashed and should not be relied upon.
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to power down hard drive (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SleepHD MOVEA.L PMgrBase,A2 ; get pointer to globals
|
||
BTST #HDPowerOn,PmgrFlags(A2); Clear the Hard Disk semaphor
|
||
BEQ.S @SkipHDSpinDown ; If set, spin down the hard disk
|
||
MOVE.L HDvector(A2),D0 ; Does the vector exist
|
||
BEQ.S @SkipHDSpinDown ; Nope... Go on
|
||
MOVEA.L D0,A2 ; Get vector to hard disk spin down task
|
||
JSR (A2) ; Spin down hard disk
|
||
@SkipHDSpinDown
|
||
JMP (A1) ; and return
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the VIA1 registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveVIA1 MOVEA.L VIA,A2
|
||
MOVE.B vBufB(A2),D0 ; load up all the VIA registers
|
||
MOVE.B vDIRB(A2),D1
|
||
MOVE.B vBufA(A2),D2
|
||
MOVE.B vDIRA(A2),D3
|
||
MOVE.B vIER(A2),D4
|
||
ORI.B #(1<<7),D4 ; set the Via Set bit so that value will stick
|
||
MOVE.B vACR(A2),D5
|
||
MOVE.B vPCR(A2),D6
|
||
MOVEM.W D0-D6,-(SP) ; save the VIA registers
|
||
JMP (A1) ; and return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the VIA2 registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveVIA2 MOVEA.L VIA2,A2
|
||
MOVE.B vBufB(A2),D0 ; load up all the VIA registers
|
||
MOVE.B vDIRB(A2),D1
|
||
MOVE.B vBufA(A2),D2
|
||
MOVE.B vDIRA(A2),D3
|
||
MOVE.B vIER(A2),D4
|
||
ORI.B #(1<<7),D4 ; set the Via Set bit so that value will stick
|
||
MOVE.B vACR(A2),D5
|
||
MOVE.B vPCR(A2),D6
|
||
MOVEM.W D0-D6,-(SP) ; save the VIA registers
|
||
BCLR.B #v2CDis2,vBufB(A2) ; lower the cache disable line to save power
|
||
JMP (A1) ; and return
|
||
|
||
IF hasNiagra THEN
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Dartanian ASC/Batman save code (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveASCBatmanDart ;
|
||
MOVEA.L UnivInfoPtr,A2 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(A2),A2 ; then to the DecoderInfo table,
|
||
MOVEA.L JAWSAddr(A2),A2 ; then to the Niagra base address,
|
||
ADDA.L #NiagraGUR+PontiSndCtl,A2 ; and finally to the sound register
|
||
;
|
||
BSET #PontiSndPWMOff,(A2) ; turn off power amps
|
||
ENDIF
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the ASC and Batman registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
batmanSnd EQU $B0 ; version number for Batman Chip
|
||
|
||
SaveASCBatman
|
||
MOVEA.L ASCBase,A2 ; point to the base of the ASC/Batman
|
||
MOVE.B ascMode(A2),-(SP) ; save the chip mode
|
||
MOVE.B ascVolControl(A2),-(SP) ; save the external sound volume control
|
||
MOVE.B $80A(A2),-(SP) ; save channel A play/record register
|
||
CMPI.B #batmanSnd,ascVersion(A2) ; is this a Batman?
|
||
BNE.S @NotBatman ; -> nope, that's all we save
|
||
MOVE.B ascTestReg(A2),-(SP) ; save test control register
|
||
|
||
MOVE.L A1,D2 ; save the return address
|
||
|
||
MOVEQ.L #0,D1 ; reg D1 = channel offset (0=A,$20=B)
|
||
@saveBatReg LEA $F09+1(A2),a1 ; save Batman channel control regs ($F00-$F09)
|
||
ADDA.L D1,a1 ; add channel offset for A or B
|
||
MOVEQ.L #10-1,D0 ;
|
||
@saveBatC MOVE.B -(a1),-(SP) ;
|
||
DBRA D0,@saveBatC ;
|
||
LEA $F17+1(A2),a1 ; save CDXA coefficient regs ($F10-$F17)
|
||
ADDA.L D1,a1 ; add channel offset for A or B
|
||
MOVEQ.L #8-1,D0 ;
|
||
@saveCDXA MOVE.B -(a1),-(SP) ;
|
||
DBRA D0,@saveCDXA ;
|
||
TST.L D1 ; channel A or B
|
||
BNE.S @BatmanDone ; already saved both channels A and B
|
||
MOVE.L #$20,D1 ; set channel offset to channel B
|
||
BRA.S @saveBatReg ; save channel B registers
|
||
@BatmanDone
|
||
|
||
MOVEA.L D2,A1 ; restore the return address
|
||
@NotBatman JMP (A1) ; and return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to poweroff Sound (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SoundPowerDown ;
|
||
MOVEA.L UnivInfoPtr,A2 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(A2),A2 ; then to the DecoderInfo table,
|
||
MOVEA.L JAWSAddr(A2),A2 ; then to the Niagra base address,
|
||
ADDA.L #NiagraGUR+PontiSndCtl,A2 ; and finally to the sound register
|
||
;
|
||
BSET #PontiSndLatchClr,(A2) ; pulse (positive) latch clear bit
|
||
BCLR #PontiSndLatchClr,(A2) ;
|
||
;
|
||
BCLR #PontiSndPwrOn,(A2) ; turn off sound power
|
||
;
|
||
JMP (A1) ; and return
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the video registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
SaveLCD Moveq #0,D1 ; Say we’re about to sleep.
|
||
Bsr SaveRestoreLCD ; Go save the world.
|
||
Jmp (A1) ; Vamoose.
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the FPU registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveFPU BTST #hwCbFPU,HWCfgFlags ; do we have an FPU?
|
||
BEQ.S @NoFPU ; -> no
|
||
FMOVEM.X FP0-FP7,-(SP) ; save general purpose registers
|
||
FMOVEM.L FPCR/FPSR/FPIAR,-(SP) ; save FPU condition registers
|
||
@NoFPU JMP (A1) ; and return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the 68040 registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveSlp040
|
||
@SaveSetRegs REG D0-D7/A3-A6
|
||
MACHINE MC68040
|
||
|
||
MOVEA.L PmgrBase,A2 ; get pointer to globals
|
||
MOVEC CACR,D7 ; get current Cache Register
|
||
MOVEQ #0,D0 ; clear register
|
||
MOVEC D0,CACR ; disable caches
|
||
CPUSHA BC ; flush both caches entirely
|
||
|
||
; Get CPU Internal State Registers
|
||
MOVEC URP,D0 ; Save User Root Pointer
|
||
MOVEC SRP,D1 ; Save Supervisor Root Pointer
|
||
MOVEC TC,D2 ; Save TC
|
||
MOVEC DTT0,D3 ; Save Data TT0
|
||
MOVEC DTT1,D4 ; Save Data TT1
|
||
MOVEC ITT0,D5 ; Save Instruction TT0
|
||
MOVEC ITT1,D6 ; Save Instruction TT1
|
||
MOVEC VBR,A3 ; Save vector base reg
|
||
MOVEC USP,A4 ; Save User Stack Pointer
|
||
MOVEC MSP,A5 ; Save Master Stack Pointer
|
||
MOVEC ISP,A6 ; Save Interrupt Stack Pointer
|
||
|
||
MOVEM.L @SaveSetRegs,SaveCPUState(A2) ; Save all them special regs
|
||
JMP (A1) ; and return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to save the 68030 registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveSlp030
|
||
@SaveSetRegs REG D0-D5
|
||
MACHINE MC68030
|
||
|
||
MOVEA.L PmgrBase,A2 ; Get pointer to our globals
|
||
PMOVE CRP,SaveCPUState.CPUMMUCRPsave(A2); Save CRP
|
||
PMOVE TC,SaveCPUState.CPUMMUTCsave(A2) ; Save TC
|
||
PMOVE TT0,SaveCPUState.CPUMMUTT0save(A2); Save TT2
|
||
PMOVE TT1,SaveCPUState.CPUMMUTT1save(A2); Save TT1
|
||
|
||
MOVEC VBR,D0 ; Also save vector base
|
||
MOVEC USP,D1 ; and alternats stack pointers
|
||
MOVEC MSP,D2 ; .
|
||
MOVEC ISP,D3 ; and old sp
|
||
MOVEC CACR,D4 ; Now save cache regs
|
||
OR.W #(1<<11)+(1<<3),D4 ; Flush caches upon return
|
||
MOVEC CAAR,D5 ;
|
||
|
||
MOVEM.L @SaveSetRegs,\
|
||
SaveCPUState.CPUVBRsave(A2) ; Save some cool registers
|
||
JMP (A1) ; and return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to setup state info before going to sleep (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
SaveSleepInfo
|
||
MOVEA.L PMgrBase,A2 ; Get pointer to our globals
|
||
MOVE.L #SleepConst,SleepSaveFlag(A2) ; set a flag that sleep has been entered
|
||
JMP (A1)
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; _Sleep routine to send a sleep command to the PMGR (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
IF hasMSC THEN
|
||
SendSleepLP PEA 'BORG' ; low power sleep signature
|
||
BCLR #LowPowerSleep,PMgrFlags2(A2) ; are we sleeping because of a low power condition?
|
||
BNE.S HaveSig ; -> yes
|
||
ADDQ.W #4,SP ; no, toss the low power signature
|
||
ENDIF
|
||
SendSleep MOVE.L A0,-(SP) ; save this dam thing
|
||
PEA SleepSig ; put the sleep signature into a buffer
|
||
HaveSig MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
MOVE.W #4,-(SP) ; pmLength = 4
|
||
MOVE.W #SleepReq,-(SP) ; pmCommand = sleep…
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the sleep command
|
||
LEA pmRBuffer+4+4(SP),SP ; clean up the stack
|
||
MOVEA.L (SP)+,A0 ; restore it
|
||
JMP (A1) ; and return
|
||
|
||
|
||
;•••••••••••••••••••••••••••••••••••••••• Wakeup •••••••••••••••••••••••••••••••••••••••••
|
||
;
|
||
; The following are a set of possible routines that are used to restore the state, or
|
||
; set necessary conditions in order for the machine to wake from sleep. For each machine
|
||
; there is a corresponding table of entries which point to the necessary routines. The
|
||
; register convention is that A0/A1 must be PRESERVED throughout all routines. All
|
||
; other register can be trashed and should not be relied upon.
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore the MMU registers for '040 (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreSlp040
|
||
@RestoreSetRegs REG D0-D7/A3-A6
|
||
MACHINE MC68040
|
||
|
||
MOVEA.L PmgrBase,A2 ; get pointer to our Globals
|
||
MOVEM.L SaveCPUState(A2),@RestoreSetRegs; get some saved special regs
|
||
MOVEC D0,URP ; restore User Root Pointer
|
||
MOVEC D1,SRP ; restore Supervisor Root Pointer
|
||
MOVEC D3,DTT0 ; restore Data TT0
|
||
MOVEC D4,DTT1 ; restore Data TT1
|
||
MOVEC D5,ITT0 ; restore Instruction TT0
|
||
MOVEC D6,ITT1 ; restore Instruction TT1
|
||
MOVEC A3,VBR ; restore VBR
|
||
MOVEC A4,USP ; restore User Stack pointer
|
||
MOVEC A5,MSP ; restore Master Stack pointer
|
||
MOVEC A6,ISP ; restore Interrupt Stack pointer
|
||
|
||
PFLUSHA ; flush ATC
|
||
MOVEC D2,TC ; restore TC
|
||
|
||
CINVA BC ; invalidate both caches
|
||
MOVEC D7,CACR ; Restore Vital CPU registers
|
||
MOVEQ #0,D7 ; Clear register for WakeRoutine to work
|
||
JMP (A1) ; return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore the MMU registers for '030 (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreSlp030
|
||
@RestoreSetRegs REG D0-D5
|
||
MACHINE MC68030
|
||
|
||
MOVEA.L PmgrBase,A2 ; get pointer to our Globals
|
||
MOVEM.L SaveCPUState.CPUVBRsave(A2),\
|
||
@RestoreSetRegs ; get some special registers
|
||
|
||
MOVEC D0,VBR ; restore the Vector Base Register
|
||
MOVEC D1,USP ; restore the User Stack Pointer
|
||
MOVEC D2,MSP ; restore the Master Stack Pointer
|
||
MOVEC D3,ISP ; restore the Interrupt Stack Pointer
|
||
|
||
PMOVE SaveCPUState.CPUMMUCRPsave(A2),\;
|
||
CRP ; restore CRP
|
||
PMOVE SaveCPUState.CPUMMUTT1save(A2),\;
|
||
TT1 ; restore TT1
|
||
PMOVE SaveCPUState.CPUMMUTT0save(A2),\;
|
||
TT0 ; restore TT2
|
||
PFLUSHA ; flush ATC
|
||
PMOVE SaveCPUState.CPUMMUTCsave(A2),\ ;
|
||
TC ; restore TC and turn on MMU
|
||
|
||
MOVEC D4,CACR ; restore the Cache register
|
||
MOVEC D5,CAAR ; restore the Cache Address register
|
||
JMP (A1) ; and return
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore the FPU registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreFPU
|
||
BTST #hwCbFPU,HWCfgFlags ; do we have an FPU?
|
||
BEQ.S @NoFPU ; -> no
|
||
FMOVEM.L (SP)+,FPCR/FPSR/FPIAR ; restore FPU condition registers
|
||
FMOVEM.X (SP)+,FP0-FP7 ; restore general purpose registers
|
||
@NoFPU JMP (A1) ; and return
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to save the video registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
RestoreLCD
|
||
MOVEQ #1,D1 ; Say we’re about to sleep.
|
||
BSR SaveRestoreLCD ; Go save the world.
|
||
JMP (A1) ; Vamoose.
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore the ASC and Batman registers (A1 = return address)
|
||
;
|
||
; These registers must be restored in the given order. If the CDXA registers
|
||
; are restored in the incorrect order Batman will be confused and not function
|
||
; appropriately. Also if the FIFO control register is set prior to the SRC
|
||
; Time Increment it will not function properly.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreASCBatman
|
||
MOVE.L ASCBase,A2
|
||
CMPI.B #batmanSnd,ascVersion(A2) ; is this a Batman?
|
||
BNE.S @NotBatman ; -> nope, that's all we save
|
||
MOVE.L A1,D2 ; save the return address
|
||
|
||
MOVEQ #$20,D1 ; reg D1 = channel offset (0=A,$20=B) <H24>
|
||
@restBatReg LEA $F10(a2),a1 ; restore CDXA coefficient regs ($F10-$F17) <H24>
|
||
ADDA.L D1,a1 ; add channel offset for A or B <H24>
|
||
MOVEQ #8-1,D0 ; <H24>
|
||
@restCDXA MOVE.B (SP)+,(a1)+ ; <H24>
|
||
DBRA D0,@restCDXA ; <H24>
|
||
|
||
LEA $F00(a2),a1 ; restore Batman channel control regs ($F00-$F09) <H24>
|
||
ADDA.L D1,a1 ; add channel offset for A or B <H24>
|
||
MOVEQ #10-1,D0 ; <H24>
|
||
@restBatC MOVE.B (SP)+,(a1)+ ; <H24>
|
||
DBRA D0,@restBatC ; <H24>
|
||
TST.L D1 ; Are we done with both channels <H24>
|
||
BEQ.S @restCont ; Yes??? Go on... <H24>
|
||
MOVEQ #0,D1 ; Set Channel A Offset <H24>
|
||
BRA.S @restBatReg ; restore channel B registers <H24>
|
||
@restCont
|
||
MOVE.B (SP)+,ascTestReg(a2) ; restore test control register <H24>
|
||
MOVEA.L D2,A1 ; restore return address <H24>
|
||
|
||
@NotBatman MOVE.B (SP)+,$80A(A2) ; restore Channel A play/record register
|
||
MOVE.B (SP)+,ascVolControl(A2) ; restore external sound volume control
|
||
MOVE.B (SP)+,ascMode(A2) ; restore chip mode
|
||
JMP (A1)
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Reenable Sound amps (A1 = return address) <H29>
|
||
;———————————————————————————————————————————————————————————————————————————————————————— |
|
||
RestoreDartAmp ; V
|
||
MOVEA.L UnivInfoPtr,A0 ; point to the ProductInfo table,
|
||
ADDA.L DecoderInfoPtr(A0),A0 ; then to the DecoderInfo table,
|
||
MOVEA.L JAWSAddr(A0),A0 ; then to the Niagra base address,
|
||
ADDA.L #NiagraGUR+PontiSndCtl,A0 ; and finally to the sound register
|
||
; |
|
||
BSET #PontiSndLatchClr,(A0) ; pulse (positive) latch clear bit <H30>
|
||
BCLR #PontiSndLatchClr,(A0) ; <H30>
|
||
; <H30>
|
||
BCLR #PontiSndPwrOn,(A0) ; turn off sound power <H30>
|
||
; |
|
||
BCLR #PontiSndPWMOff,(A0) ; turn on power amps V
|
||
JMP (A1) ; done <H29>
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore misc PmgrVars (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestorePmgrMisc
|
||
MOVE.L A1,-(SP) ; push return address on stack
|
||
CLR.L -(SP) ; zero the buffer <H18>
|
||
MOVE.L SP,-(SP) ; pmRBuffer <H18>
|
||
MOVE.L (SP),-(SP) ; pmSBuffer <H18>
|
||
CLR.W -(SP) ; pmLength = 0 <H18>
|
||
MOVE.W #batteryRead,-(SP) ; pmCommand = batteryRead <H18>
|
||
MOVEA.L SP,A0 ; point to the parameter block <H18>
|
||
_PMgrOp ; send the command <H18>
|
||
MOVEA.L pmRBuffer(A0),A2 ; get pointer to receive buffer
|
||
MOVEA.L PmgrBase,a0 ; get pointer to globals
|
||
MOVE.B (A2),Charger(A0) ; Initialize charger state
|
||
LEA pmBlkSize(SP),SP ; Remove stack frame
|
||
RTS ; that's all folks
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore the VIA1 registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreVIA1
|
||
MOVEA.L VIA,A2
|
||
MOVEM.W (SP)+,D0-D6 ; get the saved registers off the stack
|
||
MOVE.B D0,vBufB(A2) ; and stuff them back into the VIA
|
||
MOVE.B D1,vDIRB(A2)
|
||
MOVE.B D2,vBufA(A2)
|
||
MOVE.B D3,vDIRA(A2)
|
||
MOVE.B D4,vIER(A2)
|
||
MOVE.B D5,vACR(A2)
|
||
MOVE.B D6,vPCR(A2)
|
||
|
||
MOVE.B vT2CH(A2),vT2CH(A2) ; restart the timer
|
||
MOVE.B vT1CH(A2),vT1CH(A2)
|
||
JMP (A1)
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine to restore the VIA2 registers (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RestoreVIA2
|
||
MOVEA.L VIA2,A2
|
||
MOVEM.W (SP)+,D0-D6 ; get the saved registers off the stack
|
||
MOVE.B D0,vBufB(A2) ; and stuff them back into the VIA
|
||
MOVE.B D1,vDIRB(A2)
|
||
MOVE.B D2,vBufA(A2)
|
||
MOVE.B D3,vDIRA(A2)
|
||
MOVE.B D4,vIER(A2)
|
||
MOVE.B D5,vACR(A2)
|
||
MOVE.B D6,vPCR(A2)
|
||
JMP (A1)
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine for clearing interrupts (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
WakeClrInts
|
||
MOVEM.L A0-A1,-(SP) ; save very important registers
|
||
MOVEA.L VIA,A0 ; get VIA base address
|
||
MOVE.B #(1<<ifIRQ)+(1<<ifCB1),vIFR(A0) ; clear PMGR interrupts
|
||
LEA -12(SP),SP ; read any pending interrupt data from the PMGR so we
|
||
MOVE.L SP,A0 ; don't hang in ADBReInit
|
||
ADDQ.L #2,A0 ;
|
||
MOVEQ #ReadINT,D0 ; PMGR command, get interrupt flags
|
||
MOVE.L A2,-(SP)
|
||
BigJSR PMGRrecv,A2 ;
|
||
MOVE.L (SP)+,A2
|
||
LEA 12(SP),SP ;
|
||
MOVEM.L (SP)+,A0-A1 ; restore very important registers
|
||
JMP (A1) ; go home
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Wakeup routine for setting sound (A1 = return address)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
WakeSoundSet
|
||
MOVEM.L A0-A1,-(SP) ; save special registers
|
||
SUBQ.W #4,SP ; Create stack frame
|
||
MOVE.L SP,A0
|
||
MOVE.B #sndClrLtch,(A0) ; Clear the Sound latch
|
||
MOVEQ #1,D1 ; One long to send
|
||
MOVE.W #SoundSet,D0 ; PMGR command, Set Sound Control
|
||
MOVE.L A2,-(SP)
|
||
BigJSR PMGRsend,A2 ; have the PMGR clear the sound latch
|
||
MOVE.L (SP)+,A2
|
||
ADDQ.W #4,SP ; Remove stack frame
|
||
MOVEM.L (SP)+,A0-A1 ; restore special registers
|
||
JMP (A1) ; go home
|
||
|
||
;•••••••••••••••••••••••••••••••••• Screen Misc ••••••••••••••••••••••••••••••••••••••
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: RedrawScrn
|
||
;
|
||
; Inputs: A5 - Quickdraw globals
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: A0
|
||
;
|
||
; Function: updates the screen
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
RedrawScrn
|
||
BSR ScreenWakeInit ; update all slept devices <K14>
|
||
TST.B WWExist ; is the Window Manager initialized?
|
||
BNE.S @NoWW ; -> no, just leave the screen alone
|
||
|
||
SUBQ.W #4,SP ; Get some space on the stack <13>
|
||
MOVE.L SP,-(SP) ; Push pointer for GrafPort <13>
|
||
_GetPort ; Get our current port <13>
|
||
_RedrawAll ; CheckUpdate on all layers
|
||
_SetPort ; Restore port to original <13>
|
||
@NoWW
|
||
RTS ; That's all folks
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: SaveRestoreLCD (SleepLCD/RestoreLCD)
|
||
;
|
||
; Inputs: D1 - 0 -> SaveLCD, non-zero -> RestoreLCD.
|
||
;
|
||
; Outputs: None
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: This routine uses the VideoInfo record to tell it the DrHwID of the driver
|
||
; it is supposed to use in order to save the state of the LCD controller/panel.
|
||
;
|
||
; Notes: The SleepWake call in the video driver is required to do all that is necessary
|
||
; to save the state of LCD video controller so that it may be restored correctly
|
||
; upon wake. Also, the SleepWake call should paint the screen gray itself (because
|
||
; VRAM will have been non-refreshed during sleep) due to the fact that our having
|
||
; to make an addition control call from here could potentially be quite
|
||
; aesthetically unpleasing.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
With SpBlock
|
||
|
||
SaveRestoreLCD
|
||
Move.l A0,-(SP) ; Save that register
|
||
Movea.l UnivInfoPtr,A0 ; Point to the ProductInfo record.
|
||
Adda.l VideoInfoPtr(A0),A0 ; Point to the VideoInfo record.
|
||
Move.w DrvrHwID(A0),D0 ; If the DrvrHwID is zero,
|
||
Beq.s @Done ; then just leave.
|
||
|
||
Suba.w #SpBlockSize,Sp ; Allocate an SpBlock on the stack.
|
||
Movea.l Sp,A0 ; Point to it with A0.
|
||
Clr.b spSlot(A0) ; We’re only looking in Slot $0 here.
|
||
Clr.b spID(A0) ; Begin at sRsrcID 0.
|
||
Clr.b spExtDev(A0) ; No external device.
|
||
Clr.b spTBMask(A0) ; No mask in search.
|
||
Move.w #catDisplay,spCategory(A0) ; Look for: Display,
|
||
Move.w #typVideo,spCType(A0) ; Video,
|
||
Move.w #drSwApple,spDrvrSW(A0) ; Apple,
|
||
Move.w D0,spDrvrHw(A0) ; <DrHwID>.
|
||
Clr.l spParamData(A0) ; Look only for enabled sRsrcs.
|
||
Bset #foneslot,spParamData+3(A0) ; Limit search to this slot only.
|
||
_GetTypeSRsrc ; If we didn’t find the target,
|
||
Bne.s @Cleanup ; then just leave.
|
||
Move.w spRefNum(A0),D0 ; If there’s no driver, then
|
||
Beq.s @Cleanup ; just go on.
|
||
|
||
Suba.w #ioQElSize,Sp ; Allocate ioCore pBlock.
|
||
Movea.l Sp,A0 ; Set up for the control call:
|
||
Move.w D0,ioRefNum(A0) ; ioRefNum,
|
||
Move.w #cscSleepWake,csCode(A0) ; csCode,
|
||
Move.b D1,-(Sp) ; csParam,
|
||
Move.l Sp,csParam(A0) ; csParamPtr,
|
||
_Control ,Immed ; SleepWake.
|
||
Tst.b (Sp)+ ; Remove param from stack.
|
||
Adda.w #ioQElSize,Sp ; Deallocate ioCore pBlock.
|
||
|
||
@Cleanup Adda.w #SpBlockSize,Sp ; Deallocate SpBlock.
|
||
@Done Movea.l (SP)+,A0 ; restore that register
|
||
Rts
|
||
|
||
Endwith
|
||
|
||
|
||
|
||
;_PaletteDispatch OPWORD $AAA2 ; PaletteDispatch is NOT defined in this ROM.
|
||
;selectSetDepth EQU $0A13 ; SetDepth -> $0A is paramsize, $13 is the selector.
|
||
|
||
SetScreenBrightness EQU $4301
|
||
GetScreenBrightness EQU $5301 ;
|
||
DimLevel EQU 1 ;
|
||
|
||
VidStkFrame RECORD 0, DECR
|
||
VidStkCntBlk DS.B IOVQElSize ; control call parm block
|
||
VidStkVDPageInfo DS.B VDPageInfo ; params
|
||
VidStkFrameSize EQU * ; size of frame
|
||
ENDR
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <Kxx>
|
||
; Routine: ScreenWakeInit |
|
||
; v
|
||
; Inputs: none
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: SetDepth in order to set the driver in appropriate state and to tell Quickdraw
|
||
; to rebuild the world.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
ScreenWakeInit
|
||
ScreenWakeInitRegs REG D1-D2/A0-A4
|
||
WITH VidStkFrame,VDPageInfo
|
||
LINK A6,#VidStkFrameSize ; allocate variable space
|
||
MOVEM.L ScreenWakeInitRegs,-(SP) ; save them regs
|
||
|
||
LEA VidStkCntBlk(A6),A3 ; get pointer to IOPB
|
||
LEA VidStkVDPageInfo(A6),A4 ; get pointer to csParams
|
||
MOVE.L A4,csParam(A3) ; set csParams
|
||
MOVE.W #cscPowerSelect,csCode(A3) ; cscPowerSelect
|
||
|
||
MOVE.L DeviceList,D1 ; If the DeviceList is empty,
|
||
BEQ.S @ScreenWakeInitDone ; then we can’t do anything!
|
||
MOVEQ #0,D2 ; Initialize PowerSelect supported flag
|
||
|
||
@ScreenWakeInitLp ; DO {
|
||
MOVEA.L D1,A2 ; Get gDevice Handle
|
||
MOVEA.L (A2),A2 ; Dereference the handle
|
||
MOVEQ #0,D0 ; Clear both halves of D0.l.
|
||
MOVE.W gdRefNum(A2),D0 ; Get driver refnum.
|
||
BEQ.S @NoSetDepth ; If not non-zero, skip.
|
||
MOVEA.L A3,A0 ; A0 := IOPB
|
||
ORI.W #-1,D2 ; Set Flag
|
||
MOVE.L D1,-(SP) ; Push gdHandle
|
||
MOVE.W gdMode+2(A2),-(SP) ; Push the depth
|
||
CLR.L gdMode(A2) ; Clear it so stupid trap doesn't freak out
|
||
CLR.L -(SP) ; Clear all flags
|
||
MOVE.W #selectSetDepth,D0 ; Set selector to set depth
|
||
_PaletteDispatch ; Call it
|
||
@NoSetDepth
|
||
MOVE.L gdNextGD(A2),D1 ; Device := NextDevice
|
||
BNE.S @ScreenWakeInitLp ; } While !EndOfDeviceLoop
|
||
@ScreenWakeInitDone
|
||
MOVEM.L (SP)+,ScreenWakeInitRegs ; restore reg
|
||
UNLK A6 ; release stack frame
|
||
RTS ; that's all folks
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <H32>
|
||
; Routine: VidLowPwrSelect |
|
||
; v
|
||
; Inputs: D0 0 = PowerOn , nonzero = PowerDown
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: Call the video driver to set the power state to the appropriate position.
|
||
; In the case of power up, power up the hardware and call SetDepth in order to
|
||
; set the driver in appropriate state and to tell Quickdraw to rebuild the
|
||
; world.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
VidLowPwrSelect
|
||
VidLowPwrSelectRegs REG D1-D2/A0-A4
|
||
|
||
WITH VidStkFrame,VDPageInfo
|
||
LINK A6,#VidStkFrameSize ; allocate variable space
|
||
MOVEM.L VidLowPwrSelectRegs,-(SP) ; save them regs
|
||
|
||
LEA VidStkCntBlk(A6),A3 ; get pointer to IOPB
|
||
LEA VidStkVDPageInfo(A6),A4 ; get pointer to csParams
|
||
MOVE.L A4,csParam(A3) ; set csParams
|
||
Move.l #powerSelSig,csParam+4(A3) ; (For Radius, csParams is not a pointer in some cases.)
|
||
MOVE.W #cscPowerSelect,csCode(A3) ; cscPowerSelect
|
||
|
||
MOVE.L DeviceList,D1 ; If the DeviceList is empty,
|
||
Beq.s @VidLowPwrSelectDone ; then we can’t do anything!
|
||
MOVEQ #0,D2 ; Initialize PowerSelect supported flag
|
||
|
||
TST.L D0 ; IF PowerDown THEN
|
||
BNE @VidPowerDown ; branch…
|
||
|
||
@PwrUpgDevLoop ; DO {
|
||
MOVEA.L D1,A2 ; Get gDevice Handle
|
||
MOVEA.L (A2),A2 ; Dereference the handle
|
||
Moveq #0,D0 ; Clear both halves of D0.l.
|
||
MOVE.W gdRefNum(A2),D0 ; Get driver refnum.
|
||
Beq.s @NoSetDepth ; If not non-zero, skip.
|
||
MOVEA.L A3,A0 ; A0 := IOPB
|
||
Bsr PowerSelectSupported ; IF cscPowerSelect NOT supported THEN
|
||
Beq.s @NoSetDepth ; just go on.
|
||
Move.w D0,ioRefNum(A0) ; Set driver refnum
|
||
CLR.W csMODE(A4) ; Set PowerUpMode in csMode
|
||
_Control ,IMMED ; Power Up Device
|
||
BNE.S @NoSetDepth ; IF cscPowerSelect supported THEN
|
||
|
||
ORI.W #-1,D2 ; Set Flag
|
||
MOVE.L D1,-(SP) ; Push gdHandle
|
||
MOVE.W gdMode+2(A2),-(SP) ; Push the depth
|
||
CLR.L gdMode(A2) ; Clear it so stupid trap doesn't freak out
|
||
CLR.L -(SP) ; Clear all flags
|
||
MOVE.W #selectSetDepth,D0 ; Set selector to set depth
|
||
_PaletteDispatch ; Call it
|
||
@NoSetDepth
|
||
MOVE.L gdNextGD(A2),D1 ; Device := NextDevice
|
||
BNE.S @PwrUpgDevLoop ; } While !EndOfDeviceLoop
|
||
TST.W D2 ; IF SetDepthCalled THEN
|
||
BEQ.S @NoRestore ;
|
||
TST.B WWExist ; is the Window Manager initialized?
|
||
BNE.S @NoRestore ; -> no, just leave the screen alone
|
||
|
||
SUBQ.W #4,SP ; Get some space on the stack
|
||
MOVE.L SP,-(SP) ; Push pointer for GrafPort
|
||
_GetPort ; Get our current port
|
||
_RedrawAll ; CheckUpdate on all layers
|
||
_SetPort ; Restore port to original
|
||
@NoRestore
|
||
_ShowCursor ; Show Cursor
|
||
|
||
@VidLowPwrSelectDone
|
||
MOVEM.L (SP)+,VidLowPwrSelectRegs ; restore reg
|
||
UNLK A6 ; release stack frame
|
||
RTS ; that's all folks
|
||
|
||
; Power-Down Video Devices
|
||
; Set up IOPB for control call
|
||
|
||
@VidPowerDown
|
||
Moveq #0,D2 ; Assume that we’re not hiding the cursor.
|
||
MOVEA.L A3,A0 ; A0 := IOPB
|
||
|
||
@PwrDowngDevLoop ; DO {
|
||
MOVEA.L D1,A2 ; Get gDevice Handle
|
||
MOVEA.L (A2),A2 ; Dereference the handle
|
||
Moveq #0,D0 ; Clear both halve of D0.l.
|
||
Move.w gdRefNum(A2),D0 ; Get driver refNum
|
||
Beq.s @NextGD ; If not non-zero, skip.
|
||
Bsr PowerSelectSupported ; If cscPowerSelect NOT supported THEN
|
||
Beq.s @NextGD ; just go on
|
||
Move.w D0,ioRefNum(A0) ; Set driver refnum
|
||
MOVE.W #-1,csMODE(A4) ; Set PowerDown in csMode
|
||
_Control ,IMMED ; Power Down Device
|
||
Bne.s @NextGD ; If failed, keep going.
|
||
Moveq #-1,D2 ; Otherwise, hiding the cursor is okay.
|
||
@NextGD MOVE.L gdNextGD(A2),D1 ; Device := NextDevice
|
||
BNE.S @PwrDowngDevLoop ; } While !EndOfDeviceLoop
|
||
|
||
; Kill the BackLight. <H33>
|
||
LEA DBLiteBackLite,A2 ; Get pointer to Backlight driver name. |
|
||
MOVE.L A2,ioFileName(A0) ; Load it. v
|
||
_Open ; Open driver to get the refNum.
|
||
BNE.S @NoDriver ; IF Open==Successful THEN
|
||
|
||
MOVE.W #GetScreenBrightness,csCode(A0) ; get current brightness level <H49>
|
||
_Status ,IMMED ; <H49>
|
||
CMP.W #DimLevel,csParam(a0) ; only dim if level is greater than dim value <H49>
|
||
BLE.S @NoDriver ; level is already lower than dimming value <H49>
|
||
|
||
MOVE.W #SetScreenBrightness,csCode(A0) ; turn off screen brightness
|
||
MOVE.W #DimLevel,csParam(A0) ; set brightness level <H49>
|
||
_Control ,IMMED ; do it
|
||
Bne.s @NoDriver ; don't hide cursor if failed
|
||
Ori.w #-1,D2 ; otherwise, flag that we can hide the cursor
|
||
|
||
@NoDriver Tst.l D2 ; If we shouldn’t hide the cursor,
|
||
Beq.s @VidLowPwrSelectDone ; then just go on.
|
||
_HideCursor ; Otherwise, hide it.
|
||
BRA.S @VidLowPwrSelectDone ; And go on.
|
||
ENDWITH
|
||
|
||
STRING Pascal
|
||
DBLiteBackLite DC.B '.Backlight' ; Name of Backlight Driver for DBLite.
|
||
ALIGN 2
|
||
VSCDrvrName Dc.b '.VSC_Video' ; Name of Mini/Duo Dock Video Driver.
|
||
Align 2
|
||
KeyStoneDrvrName Dc.b '.Display_Video_Apple_ViSC' ; Name of Dart-class version of the VSC Video Driver.
|
||
Align 2
|
||
STRING Asis
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: PowerSelectSupported
|
||
;
|
||
; Inputs: D0.l - refNum of a video driver
|
||
; A0.l - pointer to video driver control/status IOPB for cscPowerSelect
|
||
;
|
||
; Outputs: D0.w - if non-zero, is video driver’s refNum and PowerSelect is
|
||
; supported by the video driver.
|
||
;
|
||
; Trashes: D0
|
||
;
|
||
; Function: Returns whether or not a particular video driver supports the cscPowerSelect
|
||
; call. Note that for the original two Apple video drivers that supported
|
||
; this call, we just do a name check. From now on, though, we call the
|
||
; corresponding status call. If we get back an error, we assume that the
|
||
; call is not supported. Otherwise, we check the csData field for the
|
||
; appropriate signature to be sure that cscPowerSelect is really supported.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
PowerSelectSupported
|
||
|
||
Move.w D0,-(Sp) ; Save the refNum for later.
|
||
Beq @ExitNow ; If nil, then just leave.
|
||
|
||
; Get the video driver’s name…
|
||
;
|
||
Movem.l A0-A1/D7,-(Sp) ; Save some work registers.
|
||
|
||
Not.w D0 ; Convert the refNum into…
|
||
Lsl.w #2,D0 ; …a UTable index.
|
||
|
||
Add.l UTableBase,D0 ; Get a pointer to the AuxDCEHandle.
|
||
Movea.l D0,A0 ; Get it into A0.
|
||
|
||
Movea.l (A0),A0 ; Get the AuxDCEHandle.
|
||
Movea.l (A0),A0 ; Get the AuxDCEPtr.
|
||
|
||
Move.w dCtlFlags(A0),D0 ; Get the device flags.
|
||
Movea.l dCtlDriver(A0),A0 ; Get the driver.
|
||
Btst #dRAMBased,D0 ; If it’s not in RAM, then
|
||
Beq.s @GetName ; it’s already a pointer.
|
||
Movea.l (A0),A0 ; Otherwise, get pointer to driver.
|
||
@GetName Lea drvrName(A0),A0 ; Point to the driver name.
|
||
Move.l A0,D7 ; Save it for later.
|
||
|
||
; Check for the Mini/Duo Dock Video Driver…
|
||
;
|
||
Moveq #0,D0 ; Clear both halves of D0.l.
|
||
Move.b (A0)+,D0 ; Get the length of the driver name.
|
||
Swap D0 ; Save it.
|
||
Lea VSCDrvrName,A1 ; Point to the Mini/Duo Dock Video Driver’s name.
|
||
Move.b (A1)+,D0 ; Get the length of the driver name.
|
||
_CmpString ; Compare the two names.
|
||
Tst.w D0 ; If they match,
|
||
Beq.s @Supported ; then just go on.
|
||
|
||
; Check for the Dart-class version of the VSC Video Driver.
|
||
;
|
||
Movea.l D7,A0 ; Re-point to the driver we’re checking.
|
||
Moveq #0,D0 ; Clear both halves of D0.
|
||
Move.b (A0)+,D0 ; Get the length of the driver name.
|
||
Swap D0 ; Save it.
|
||
Lea KeyStoneDrvrName,A1 ; Point to the Dart-class version of the VSC Video Driver.
|
||
Move.b (A1)+,D0 ; Get the length of the driver name.
|
||
_CmpString ; Compare the two names.
|
||
Tst.w D0 ; If they match,
|
||
Beq.s @Supported ; then just go on.
|
||
|
||
; Now, generically check the driver by making the cscPowerSelect status call…
|
||
;
|
||
With VDPageInfo
|
||
|
||
Movem.l (Sp)+,A0-A1/D7 ; Restore work registers.
|
||
Move.l A0,D0 ; Save A0 (IOPB ptr) for now.
|
||
Movea.l csParam(A0),A0 ; Point to csParams data.
|
||
Clr.l csData(A0) ; Clear the verification field.
|
||
Movea.l D0,A0 ; Restore A0.
|
||
Move.w (Sp),ioRefNum(A0) ; Get the driver refNum.
|
||
_Status ,Immed ; If cscPowerSelect is not supported,
|
||
Bne.s @NotThere ; then just say so.
|
||
|
||
Move.l A0,-(Sp) ; Save A0.
|
||
Movea.l csParam(A0),A0 ; Point to the csParams data.
|
||
Cmpi.l #powerSelSig,csData(A0) ; Check for cscPowerSelect.
|
||
Movea.l (Sp)+,A0 ; Restore A0.
|
||
Beq.s @Supported1 ; If cscPowerSelect is supported, then just go on.
|
||
|
||
@NotThere Addq #2,Sp ; Strip refNum off the stack.
|
||
Moveq #0,D0 ; Say that cscPowerSelect is not supported.
|
||
Rts ; And leave.
|
||
|
||
Endwith
|
||
|
||
; Clean up and go home…
|
||
;
|
||
@Supported Movem.l (Sp)+,A0-A1/D7 ; Restore the work registers.
|
||
@Supported1 Move.w (Sp)+,D0 ; Get the refNum back into D0.
|
||
@ExitNow Rts ; Return to caller.
|
||
|
||
|
||
;•••••••••••••••••••••••••••••••••••• Battery Stuff •••••••••••••••••••••••••••••••••••••
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: GetLevel
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager globals
|
||
;
|
||
; Outputs: D0 - normalized battery level (-1 to 4)
|
||
; CCR - BNE if a valid battery level is being returned
|
||
;
|
||
; Trashes: D0-D3, A0
|
||
;
|
||
; Function: Reads the battery power level from the Power Manager and adds this value into
|
||
; an eight value circular queue. If the queue is full then an average of these
|
||
; values is calculated. Next, the averaged value is compared with the warning
|
||
; and cutoff values in PRAM to determine if the average is greater then reserve
|
||
; or what fractional part of reserve (1, 3/4, 1/2, or 1/4).
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
GetLevel CLR.L -(SP) ; make space for a buffer
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #batteryNow,-(SP) ; pmCommand = get battery data
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
|
||
MOVEA.L SP,A0 ; point to the buffer
|
||
MOVEQ #0,D3
|
||
MOVE.B (A0)+,Charger(A2) ; get the charger state
|
||
MOVE.B (A0),D3 ; and the battery level
|
||
ADDQ.W #4,SP ; toss the stack frame
|
||
|
||
BTST #ChrgState,Charger(A2) ; get the charger state (connected/disconnected)
|
||
BEQ.S @ChargeSame ; -> no change in charger state
|
||
ST TOdirtyFlag(A2) ; Flag TOs need updating
|
||
|
||
@ChargeSame MOVEQ #0,D0
|
||
MOVE.B BatQIndex(A2),D0 ; get the next index into the circular queue
|
||
SUBQ.B #1,D0
|
||
BPL.S @IndexOK ; -> index is still valid
|
||
MOVEQ #7,D0 ; it wrapped, so reset it
|
||
@IndexOK MOVE.B D0,BatQIndex(A2) ; save the new index
|
||
|
||
MOVE.B D3,BatQ(A2,D0.W) ; put the latest battery level into queue
|
||
TST.B BatQ(A2) ; wait for full queue before averaging
|
||
BEQ.S GetLevel
|
||
|
||
MOVEQ #0,D3
|
||
MOVE.B BatQ(A2),D0 ; calculate the average of the last 8 samples
|
||
ADD.W D0,D3
|
||
MOVE.B BatQ+1(A2),D0
|
||
ADD.W D0,D3
|
||
MOVE.B BatQ+2(A2),D0
|
||
ADD.W D0,D3
|
||
MOVE.B BatQ+3(A2),D0
|
||
ADD.W D0,D3
|
||
MOVE.B BatQ+4(A2),D0
|
||
ADD.W D0,D3
|
||
MOVE.B BatQ+5(A2),D0
|
||
ADD.W D0,D3
|
||
MOVE.B BatQ+6(A2),D0
|
||
ADD.W D0,D3
|
||
MOVE.B BatQ+7(A2),D0
|
||
ADD.W D0,D3
|
||
LSR.W #1,D3 ; D3 = 4*avg
|
||
|
||
MOVEQ #0,D2
|
||
MOVE.B LowWarn(A2),D2 ; D2 = low warning level
|
||
MOVEQ #0,D1
|
||
MOVE.B CutOff(A2),D1 ; D1 = cutoff level
|
||
SUB.W D1,D2 ; D2 = warning - cutoff
|
||
ASL.W #2,D1 ; D1 = 4*cutoff
|
||
|
||
MOVEQ #4,D0 ; level 4
|
||
ADD.W D2,D1 ; D1 = 4*cutoff + 1(warning - cutoff)
|
||
CMP.W D1,D3 ; power ≤ 1/4 reserve
|
||
BLS.S @foundlevel
|
||
|
||
MOVEQ #3,D0 ; level 3
|
||
ADD.W D2,D1 ; D1 = 4*cutoff + 2(warning - cutoff)
|
||
CMP.W D1,D3 ; power ≤ 1/2 reserve
|
||
BLS.S @foundlevel
|
||
|
||
MOVEQ #2,D0 ; level 2
|
||
ADD.W D2,D1 ; D1 = 4*cutoff + 3(warning - cutoff)
|
||
CMP.W D1,D3 ; power ≤ 3/4 reserve
|
||
BLS.S @foundlevel
|
||
|
||
MOVEQ #1,D0 ; level 1
|
||
ADD.W D2,D1 ; D1 = 4*cutoff + 4(warning - cutoff)
|
||
CMP.W D1,D3 ; power ≤ reserve
|
||
BLS.S @foundlevel
|
||
|
||
MOVEQ #0,D0 ; level 0
|
||
MOVE.W Hysteresis(A2),D2 ; D2 = hysteresis
|
||
ASL.W #2,D2 ; D2 = 4 * hysteresis
|
||
ADD.W D2,D1 ; D1 = 4*cutoff + 4(warning - cutoff) + 4*hysteresis
|
||
CMP.W D1,D3 ; power ≤ reserve + hysteresis
|
||
BLS.S @foundlevel
|
||
|
||
MOVEQ #-1,D0 ; power > reserve + hysteresis
|
||
|
||
@foundlevel LSR.W #2,D3 ; D3 = average
|
||
MOVE.B D3,BatAvg(A2) ; save it
|
||
TST.B BatQ(A2) ; set data valid condition
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: GetExtLevel
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager globals
|
||
;
|
||
; Outputs: D0 - normalized battery level (-1 to 4)
|
||
; CCR - BNE if a valid battery level is being returned
|
||
;
|
||
; Trashes: D0-D3, A0
|
||
;
|
||
; Function: Reads the extended battery power level from the Power Manager (which is
|
||
; pre-averaged by the PMGR). Next, the value is compared with the warning
|
||
; and cutoff values in PRAM to determine if the average is greater then
|
||
; reserve or what fractional part of reserve (1, 2/3, or 1/3).
|
||
;
|
||
; Note: The extended battery status command supports a word-sized battery
|
||
; level. Currently the PMGR on DBLite uses a 9-bit A/D to sample
|
||
; the battery voltage.
|
||
;
|
||
; The battery warning levels returned will be zero if no battery is
|
||
; currently connected.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
GetExtLevel CLR.W -(SP) ; setup a buffer for the result
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readBattWarning,-(SP) ; pmCommand = get warning/cutoff levels
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; go get them
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
MOVE.W (SP)+,LowWarn(A2) ; save the new warning/cutoff levels
|
||
|
||
CLR.L -(SP)
|
||
CLR.L -(SP)
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readExtBatt,-(SP) ; pmCommand = get extended battery data
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
|
||
MOVEA.L SP,A0 ; point to the buffer
|
||
MOVEQ #%00001011,D0 ; mask off the bits we want in the flags byte,
|
||
AND.B (A0),D0
|
||
MOVE.B Charger(A2),D1 ; get the old charger state, <H13>
|
||
MOVE.B D0,Charger(A2) ; and save the new charger state
|
||
MOVE.B (A0)+,D0 ; get the unmodified flags <H41>
|
||
EOR.B D0,D1 ; has the charger state changed since last time? <H13>
|
||
BTST #HasCharger,D1 ; <H13>
|
||
BEQ.S @ChargeSame ; -> no <H13>
|
||
ST TOdirtyFlag(A2) ; yes, flag that timeouts need updating <H13>
|
||
|
||
@ChargeSame MOVE.W (A0),D3
|
||
LSR.W #1,D3
|
||
MOVE.B D3,BatAvg(A2) ; save the 8-bit battery voltage
|
||
ADD.W (A0)+,D3 ; D3 = 3*(8 bit battery voltage)
|
||
ADDQ.W #8,SP ; toss the buffer
|
||
|
||
BTST #HasCharger,D0 ; is a charger connected? <H13>
|
||
BNE.S @HaveCharger ; -> yes, we don't care about the battery level <H13>
|
||
BTST #2,D0 ; is a battery connected? <H41>
|
||
BEQ.S @HaveCharger ; -> no, don't bother with battery level
|
||
|
||
MOVEQ #0,D2 ; <H44>
|
||
MOVE.B LowWarn(A2),D2 ; D2 = low warning level |
|
||
MOVEQ #0,D1 ; V
|
||
MOVE.B CutOff(A2),D1 ; D1 = cutoff level
|
||
SUB.W D1,D2 ; D2 = warning - cutoff
|
||
MOVE.W D1,D0
|
||
ADD.W D0,D1
|
||
ADD.W D0,D1 ; D1 = 3*cutoff
|
||
|
||
MOVEQ #4,D0 ; level 4
|
||
ADD.W D2,D1 ; D1 = 3*cutoff + 1(warning - cutoff)
|
||
CMP.W D1,D3 ; power ≤ 1/3 reserve
|
||
BLS.S @foundlevel
|
||
|
||
MOVEQ #3,D0 ; level 3
|
||
ADD.W D2,D1 ; D1 = 3*cutoff + 2(warning - cutoff)
|
||
CMP.W D1,D3 ; power ≤ 2/3 reserve
|
||
BLS.S @foundlevel
|
||
|
||
; (level 2 is not used, so we don't return it)
|
||
|
||
MOVEQ #1,D0 ; level 1
|
||
ADD.W D2,D1 ; D1 = 3*cutoff + 3(warning - cutoff)
|
||
CMP.W D1,D3 ; power ≤ reserve
|
||
BLS.S @foundlevel
|
||
|
||
MOVEQ #0,D0 ; level 0
|
||
MOVE.W Hysteresis(A2),D2 ; D2 = hysteresis
|
||
ADD.W D2,D1
|
||
ADD.W D2,D1
|
||
ADD.W D2,D1 ; D1 = 3*cutoff + 3(warning - cutoff) + 3*hysteresis
|
||
CMP.W D1,D3 ; power ≤ 1.0 reserve + hysteresis
|
||
BLS.S @foundlevel
|
||
|
||
@HaveCharger
|
||
MOVEQ #-1,D0 ; return a "charged" battery level in case someone cares
|
||
|
||
@foundlevel MOVEQ #1,D1 ; always return BNE for data valid
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: LeadScaledBatteryInfo (PowerDispatch selector #9)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager globals
|
||
;
|
||
; Outputs: D0 - bits 31: 1=battery installed
|
||
; 30: 1=battery is charging
|
||
; 29: 1=charger connected
|
||
; 23-16: warning level (0-255)
|
||
; 15: don't use this one (needs to be set if the selector isn't implemented)
|
||
; 7- 0: battery level (0-255)
|
||
;
|
||
; Trashes: D1, D2, A0
|
||
;
|
||
; Function: Returns scaled warning and battery levels, plus a couple of flags for
|
||
; portables that support sealed lead acid batteries.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
LeadScaledBatteryInfo
|
||
MOVEQ #3,D0 ; mask off the battery charging and charger installed bits
|
||
AND.B charger(a2),D0 ; <H39>
|
||
MOVEQ #0,D2 ; get the maximum battery voltage
|
||
MOVE.B @MaxVolts(D0),D2
|
||
SUB.B CutOff(A2),D2 ; <H37>
|
||
ADDQ.B #1<<2,D0 ; set the battery installed bit
|
||
ROR.W #3,D0 ; put the battery flags into bits 15-13 (temporarily)
|
||
|
||
MOVEQ #0,D1 ; scale the warning level (256*warning/max)
|
||
MOVE.B LowWarn(A2),D1
|
||
SUB.B CutOff(A2),D1 ; <H37>
|
||
BSR.S ScaleLevel ; pin the level and save it
|
||
SWAP D0 ; put it all in the upper word
|
||
|
||
MOVEQ #0,D1 ; scale the battery level (256*batt/max)
|
||
move.b BatAvg(A2),d1 ; get the current averaged battery <H39>
|
||
SUB.B CutOff(A2),D1 ; <H37>
|
||
BSR.S ScaleLevel ; pin the level and save it
|
||
RTS
|
||
|
||
@MaxVolts DC.B 123 ; [6.35v] not charging, no charger
|
||
DC.B 188 ; [7.00v] not charging, has charger
|
||
DC.B 123 ; [6.35v] is charging, no charger (can't get here)
|
||
DC.B 208 ; [7.20v] is charging, has charger
|
||
|
||
|
||
ScaleLevel ASL.L #8,D1 ; multiply by 256
|
||
DIVU D2,D1 ; divide a level by the maximum
|
||
CMPI.W #255,D1 ; higher than max (well, it _might_ happen)?
|
||
BLS.S @SaveLevel ; -> no, use it as is
|
||
MOVE.B #255,D1 ; yes, pin it at maximum
|
||
@SaveLevel MOVE.B D1,D0 ; save the scaled level
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: MultiScaledBatteryInfo (PowerDispatch selector #9)
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager globals
|
||
;
|
||
; Outputs: D0 - bits 31: 1=battery installed
|
||
; 30: 1=battery is charging
|
||
; 29: 1=charger connected
|
||
; 23-16: warning level (0-255)
|
||
; 15: don't use this one (needs to be set if the selector isn't implemented)
|
||
; 7- 0: battery level (0-255)
|
||
;
|
||
; Trashes: D1, D2, A0
|
||
;
|
||
; Function: Returns scaled warning and battery levels, plus a couple of flags for
|
||
; portables that support multiple battery types. If no battery is currently
|
||
; connected, it will return zero for both the warning and battery levels.
|
||
; It uses the extended battery status command which returns the following info:
|
||
;
|
||
; +0 flags (bits)
|
||
; 7: chargeable battery
|
||
; 6: "energy used" count valid
|
||
; 5: 0
|
||
; 4: battery termperature valid
|
||
; 3: dead battery
|
||
; 2: battery connected
|
||
; 1: hi-charge enabled
|
||
; 0: charger installed
|
||
; +1 voltage (H)
|
||
; +2 voltage (L)
|
||
; +3 ambient temperature (°C)
|
||
; +4 battery temperature (°C)
|
||
; +5 power usage rate
|
||
; +6 energy used (H)
|
||
; +7 energy used (L)
|
||
;
|
||
; and the battery info command, which returns the following info:
|
||
;
|
||
; +0 max energy used count (H)
|
||
; +1 max energy used count (L)
|
||
; +2 min voltage--charging (H)
|
||
; +3 min voltage--charging (L)
|
||
; +4 max voltage--charging (H)
|
||
; +5 max voltage--charging (L)
|
||
; +6 min voltage--discharging (H)
|
||
; +7 min voltage--discharging (L)
|
||
; +8 max voltage--discharging (H)
|
||
; +9 max voltage--discharging (L)
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
MultiScaledBatteryInfo
|
||
LINK A6,#0
|
||
|
||
; get parameters associated with the current type of battery...
|
||
|
||
CLR.W -(SP) ; put a buffer on the stack
|
||
CLR.L -(SP)
|
||
CLR.L -(SP)
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readBatteryInfo,-(SP) ; pmCommand = return battery info
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
|
||
; get the current battery state and battery level...
|
||
|
||
CLR.L -(SP)
|
||
CLR.L -(SP)
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readExtBatt,-(SP) ; pmCommand = get extended battery data
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
|
||
MOVEA.L SP,A0 ; point to the buffer
|
||
MOVEQ #%01000111,D0 ; mask off the "energy used" count valid,
|
||
AND.B (A0)+,D0 ; battery installed, charging, and charger connected bits
|
||
ROR.W #3,D0 ; shift them into bits 15-13 and 3 (temporarily)
|
||
MOVE.L (A0)+,D2 ; get the battery voltage into the upper word (NOTE: unaligned read)
|
||
ADDQ.W #1,A0 ; skip over the power usage rate
|
||
MOVE.W (A0)+,D2 ; get the "energy used" count into the lower word
|
||
MOVE.L A0,SP ; toss the buffer
|
||
|
||
TST.W D0 ; is a battery installed?
|
||
BPL.S @NoBattery ; -> no, just swap the flags and exit
|
||
|
||
BCLR #6-3,D0 ; is the "energy used" count valid?
|
||
BEQ.S @UseVolts ; -> no, use the voltages
|
||
|
||
; calculate the current level based on the "energy used" count...
|
||
|
||
@UseCount SWAP D0 ; put the flags into the upper word, set warning level=0
|
||
MOVEQ #0,D1 ; get the maximum energy count (zero-extended)
|
||
MOVE.W (SP),D1
|
||
SUB.W D2,D1 ; calculate how much energy is left (max-used)
|
||
BLE.S @Done ; -> max≤used, so pin at zero
|
||
MOVE.W (SP),D2 ; get the maximum
|
||
BSR.S ScaleLevel ; scale the level and save it
|
||
BRA.S @Done
|
||
|
||
; calculate the current level based on voltages...
|
||
|
||
@UseVolts LEA 4(SP),A0 ; point to the charge parameters
|
||
BTST #14,D0 ; are we charging?
|
||
BNE.S @Charging ; -> yes, we're pointing to the right place
|
||
ADDQ.W #4,A0 ; no, point to the discharge parameters
|
||
@Charging MOVE.W (A0),D2 ; calculate max-min
|
||
SUB.W -(A0),D2
|
||
BLE.S @NoBattery ; -> max≤min (strange…), so bail
|
||
|
||
BTST #14,D0 ; are we charging? <H37>
|
||
BNE.S @NoWarning ; -> yes, there's no warning level <H37>
|
||
MOVEQ #0,D1
|
||
MOVE.B LowWarn(A2),D1 ; calculate warning-min
|
||
ADD.B D1,D1
|
||
SUB.W (A0),D1
|
||
BLE.S @NoWarning ; -> warning≤min, so pin at zero
|
||
BSR.S ScaleLevel ; scale the level and save it
|
||
@NoWarning SWAP D0 ; put it all in the upper word
|
||
|
||
MOVE.L D2,D1 ; get the battery voltage
|
||
CLR.W D1 ; and zero extend it
|
||
SWAP D1
|
||
SUB.W (A0),D1 ; calculate battery-min
|
||
BLE.S @Done ; -> battery≤min, so pin at zero
|
||
BSR.S ScaleLevel ; scale the level and save it
|
||
|
||
@Done UNLK A6 ; get rid of any lingering buffers
|
||
RTS
|
||
|
||
@NoBattery CLR.B D0 ; make sure the battery level is zero
|
||
SWAP D0 ; put the flags in the upper word
|
||
BRA.S @Done ; and exit
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <H54>
|
||
; Routine: LeadAbsoluteBatteryVoltage
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager globals
|
||
;
|
||
; Outputs: D0 - fixed-point representation of the absolute battery voltage
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: Calculates the absolute battery voltage for lead acid batteries. The result
|
||
; is returned as a fixed point number (16 bits integer + 16 bits fraction),
|
||
; giving a range from 0 to 32767.999984741 volts. This should be enough to
|
||
; handle the next few batteries we do.
|
||
;
|
||
; For lead acid batteries, the voltage is calculated as:
|
||
;
|
||
; voltage = ((power/100) + 5.12) volts
|
||
;
|
||
; For a ‘power’ range of 0 to 255, we get a voltage range of 5.12 to 7.67 volts.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
LeadAbsoluteBatteryVoltage
|
||
MOVEQ #0,D0 ; zero-extend the battery level
|
||
MOVE.B BatAvg(A2),D0
|
||
SWAP D0 ; convert it to fixed-point
|
||
DIVU #100,D0 ; divide by 100 to convert to relative volts
|
||
SWAP D0 ; get the result back in the right order
|
||
ADDI.L #(5<<16)+(65536*12/100),D0 ; add 5.12v to convert to absolute
|
||
RTS
|
||
|
||
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <H54>
|
||
; Routine: PGEAbsoluteBatteryVoltage
|
||
;
|
||
; Inputs: A2 - pointer to Power Manager globals
|
||
;
|
||
; Outputs: D0 - fixed-point representation of the absolute battery voltage
|
||
;
|
||
; Trashes: A0, D1
|
||
;
|
||
; Function: Calculates the absolute battery voltage for PG&E-based machines. The result
|
||
; is returned as a fixed point number (16 bits integer + 16 bits fraction),
|
||
; giving a range from 0 to 32767.999984741 volts. This should be enough to
|
||
; handle the next few batteries we do.
|
||
;
|
||
; PG&E essentially uses a 9-bit A/D for a voltage range of 7 to 21 volts.
|
||
; So the voltage is calculated as:
|
||
;
|
||
; voltage = ((power*14/512) + 7) volts
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
PGEAbsoluteBatteryVoltage
|
||
CLR.L -(SP) ; allocate space for the extended battery info
|
||
CLR.L -(SP)
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength = 0
|
||
MOVE.W #readExtBatt,-(SP) ; pmCommand = get extended battery data
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; send the command
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
|
||
MOVEQ #0,D0
|
||
MOVEA.L SP,A0 ; point to the buffer
|
||
BTST #2,(A0)+ ; is a battery connected?
|
||
BEQ.S @NoBattery ; -> no, we're done
|
||
MOVEQ #14,D0 ; battery level * 14
|
||
MULU (A0),D0 ; (NOTE: unaligned read)
|
||
SWAP D0 ; convert it to fixed point
|
||
MOVEQ #9,D1
|
||
LSR.L D1,D0 ; divide by 512 to convert to relative volts
|
||
ADDI.L #7<<16,D0 ; add 7v to convert to absolute
|
||
|
||
@NoBattery ADDQ.W #8,SP ; toss the buffer
|
||
RTS
|
||
|
||
|
||
;•••••••••••••••••••••••••••••••••••••• Utilities •••••••••••••••••••••••••••••••••••••••
|
||
|
||
;———————————————————————————————————————————————————————————————————————————————————————— <H22>
|
||
; PostUserNmMsg - post user warning notification msg
|
||
;
|
||
; General routine which will post a user warning notification mgr message using the
|
||
; "UNmQEntry" PmgrRec notification mgr record.
|
||
;
|
||
; Input: a0.l = ptr to notification string
|
||
; d0.w = indicates which completion routine
|
||
; 0 -> does nothing - leaves flashing icon (default)
|
||
; 1 -> removes message and icon
|
||
;
|
||
; Output: none
|
||
;
|
||
Export PostUserNmMsg
|
||
PostUserNmMsg
|
||
@regs reg d1/a0/a2
|
||
movem.l @regs,-(sp)
|
||
|
||
movea.l PmgrBase,a2 ; a2 = ptr to pmgr globals
|
||
bset.b #PmgrAvoidUsrMsg,PmgrFlags1(a2) ; are warning messages enabled?
|
||
bne.s @skip ; not enabled - skip it
|
||
move.l a0,d1 ; is there a string? <H26>
|
||
beq.s @skip ; no message to post
|
||
|
||
lea UNmQEntry(a2),a0 ; addr of notification record
|
||
move.l d1,nmStr(a0) ; set the string
|
||
move.w #8,qType(a0)
|
||
move.l #-1,nmSound(a0) ; use default sound
|
||
clr.w nmMark(a0) ; No mark
|
||
move.l lpSICNHndl(a2),nmIcon(a0) ; Use the icon
|
||
lea @nmproc,a2 ; no completion routine
|
||
subq.w #1,d0 ; the "other" completion routine? <H26>
|
||
bne.s @postmsg ; no - use default <H26>
|
||
lea @oneShot,a2 ; use routine which removes icon <H26>
|
||
@postMsg
|
||
move.l a2,nmResp(a0) ; set completion routine
|
||
_NMInstall ; post message
|
||
@skip
|
||
movem.l (sp)+,@regs
|
||
@nmproc rts ; empty completion routine <H26>
|
||
|
||
@oneShot ; <H26>
|
||
movea.l (sp)+,a1 ; save return addr <H26>
|
||
movea.l (sp)+,a0 ; get ptr to BNmQEntry <H26>
|
||
_NMRemove ; remove the bad battery notification <H26>
|
||
movea.l PmgrBase,a0 ; get ptr to pmgr globals <H26>
|
||
bclr.b #PmgrAvoidUsrMsg,PmgrFlags1(a0) ; allow user messages again <H26>
|
||
jmp (a1) ; return to caller <H26>
|
||
|
||
|
||
|
||
;••••••••••••••••••••••••••••••••••••••• ModemTables •••••••••••••••••••••••••••••••••••••••• <H31>
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Modem Table
|
||
;
|
||
; Tables of offsets to low level hardware dependent routines which are used for
|
||
; internal modem control
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (ModemTableEnd-ModemTable) ; size of table
|
||
ModemTable DC.L StdModemOn-ModemTable ; standard routine to turn on modem
|
||
DC.L StdModemOff-ModemTable ; standard routine to turn off modem
|
||
DC.L StdModemType-ModemTable ; standard routine to get modem type
|
||
ModemTableEnd
|
||
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: TurnModemPowerOn/Off
|
||
;
|
||
; Input: a0.l = ptr to powermanager pb + 4 byte general data buffer(pmData)
|
||
; - pre-initialized so pmSend/pmReceive points to pmData
|
||
; d1.b = modem status bits from power manager
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: Power control for the internal modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
TurnModemPowerOff
|
||
bclr.l #ModemPwr,d1 ; clear bit in saved modem status bits
|
||
bra.s SetData
|
||
TurnModemPowerOn
|
||
and.b #7,d1 ; mask only <ring wakeup><port select><modem power>
|
||
bset.l #ModemPwr,d1 ; set bit in saved modem status bits
|
||
SetData move.b d1,pmData(a0) ; turn on +5V and -5V to modem bit
|
||
move.w #1,pmLength(a0) ; xmit one byte
|
||
move.w #modemSet,pmCommand(a0) ; modem set command
|
||
_PmgrOp ; turn on +5V and -5V to modem
|
||
rts
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: Enable/DisableModem
|
||
;
|
||
; Input: a0.l = ptr to powermanager pb + 4 byte general data buffer
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: Controls the modem enable line
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
DisableModem
|
||
move.b #ModemOff,pmData(a0) ; disable modem - sense of bit is reversed
|
||
bra.s SetCount
|
||
EnableModem
|
||
move.b #ModemOn,pmData(a0) ; enable modem - sense of bit is reversed
|
||
SetCount move.w #1,pmLength(a0) ; xmit one byte
|
||
move.w #powerCntl,pmCommand(a0) ; power control command
|
||
_PmgrOp ; call the power manager
|
||
rts
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: TurnOffModemSoundSelect
|
||
;
|
||
; Input: none
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: turns off input source if modem selected
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
TurnOffModemSoundSelect
|
||
jsrTBL sndInputSource ; is a sound source selected?
|
||
cmp.B #2,D0 ; is the modem input selected ?
|
||
bne.s @exitSoundInput ; continue with code
|
||
|
||
move.b #0,d0 ; get current volume
|
||
jsrTBL sndPlayThruVol ; set volume for playthrough
|
||
moveq.l #sndInputOff,d0
|
||
jsrTbl sndInputSelect ; select aux source
|
||
@exitSoundInput
|
||
rts
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: DelayNMsec
|
||
;
|
||
; Input: d0.l = msec to delay
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: Spin wait for N milliseconds
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
EXPORT DelayNMsec
|
||
DelayNMsec
|
||
@savedregs reg d0-d1 ; working set of register
|
||
movem.l @savedregs,-(sp) ; save working set
|
||
move.w d0,d1 ; number of msec
|
||
subq #1,d1 ; subtract 1 for dbra loop
|
||
@msec move.w TimeDBRA,d0 ; load 1ms delay in d0
|
||
@Delay dbra d0,@Delay ; wait 1 ms
|
||
dbra d1,@msec ; repeat 1ms d1 times
|
||
movem.l (sp)+,@savedregs ; restore working set
|
||
rts
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: StdModemOn
|
||
;
|
||
; Input: a0.l = ptr to powermanager pb + 4 byte general data buffer
|
||
; d1.b = modem status bits from power manager
|
||
;
|
||
; Outputs: condition codes
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: Power the internal dartanian modem
|
||
;
|
||
; The following is a summary of the devices and which power manager commands to use
|
||
; to control them.
|
||
;
|
||
; device Pmgr cmd port0 bit signal name
|
||
; ----- --------- ------- -----------
|
||
; SCC powerCntl P01/sccOn *SCC_CNTL
|
||
; external port powerCntl P04/serOn *SERIAL_POWER
|
||
; internal modem powerCntl P03/ModemOn MODEM_PWR
|
||
; modemSet P06 *MODEM_PWROUT
|
||
;
|
||
; Additionally for the internal modem, MODEM_RESET (a Orca/via2 signal) must be
|
||
; manipulated by changing it from an input to and output to de-assert reset.
|
||
;
|
||
; Powering on the SCC and the external ports only involves sending the correct power
|
||
; manager commands. Powering on the internal modem involves some timing delays and a
|
||
; specific sequence of commands.
|
||
;
|
||
; To power the SCC and external ports:
|
||
; turn on SCC
|
||
; turn on external line drivers
|
||
;
|
||
; To power the internal modem:
|
||
; clear MODEM_RESET
|
||
; turn on +5V and -5V to modem (MODEM_PWROUT)
|
||
; ... wait >2ms to allow +5V and -5V to settle
|
||
; set MODEM_RESET
|
||
; enable the modem (*MODEM_PWR)
|
||
; wait >5ms to allow reset time
|
||
; clear MODEM_RESET
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
StdModemOn
|
||
bclr.b #7,([VIA2],vBufB) ; clear modem-reset before turning on power
|
||
|
||
bsr.s TurnModemPowerOn ; turn on power
|
||
|
||
moveq.l #3,d0 ; delay 3 msec (50% margin)
|
||
bsr.s DelayNMsec ; ... wait for +5v and -5V to ramp
|
||
|
||
bset.b #7,([VIA2],vBufB) ; set reset before enabling modem
|
||
bsr EnableModem ; enable modem
|
||
|
||
moveq.l #8,d0 ; delay 8 msec
|
||
bsr.s DelayNMsec ; ... for reset pulse
|
||
|
||
bclr.b #7,([VIA2],vBufB) ; clear modem-reset
|
||
|
||
; enable modem sound interrupt
|
||
move.l ([PmgrBase],MdmSndVect),jModemSnd; install in Level 1 VIA1 dispatch table
|
||
move.b #((1<<ifIRQ)+\
|
||
(1<<ifCB2)),([VIA],vIER) ; enable modem sound interrupt
|
||
|
||
moveq.l #0,d0 ; set CCR, turn on scc power on return
|
||
RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: StdModemOff
|
||
;
|
||
; Input: a0.l = ptr to powermanager pb + 4 byte general data buffer
|
||
; d1.b = modem status bits from power manager
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: Power off the internal dartanian modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
StdModemOff
|
||
move.b #(1<<ifCB2),([VIA],vIER) ; disable the modem sound interrupt <t28>
|
||
|
||
bsr.s TurnOffModemSoundSelect ; turn off modem sound if needed
|
||
bsr.s DisableModem ; disable modem
|
||
|
||
move.l #512,d0 ; Delay 512ms for modem to save some of its state
|
||
bsr.s DelayNMsec ; ... wait for +5v and -5V to ramp
|
||
|
||
bsr.s TurnModemPowerOff ; power off modem
|
||
|
||
moveq.l #8,d0 ; delay 8 msec
|
||
bsr.s DelayNMsec ; ... wait for power ramp down
|
||
moveq.l #0,d0 ; set CCR, turn off scc power on return
|
||
rts ; <H45>
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: StdModemType
|
||
;
|
||
; Input:
|
||
;
|
||
; Outputs: d0.l has the modem Type
|
||
;
|
||
; Trashes: d0
|
||
;
|
||
; Function: Returns type of modem installed in TIM Modem
|
||
;
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
StdModemType
|
||
moveq.l #ModemTypeSerial,d0 ; serial modem on TIM
|
||
rts
|
||
|
||
|
||
ENDIF ; {hasPwrControls}
|
||
|
||
;••••••••••••••••••••••••••••••••••••••• CommsPowerTables •••••••••••••••••••••••••••••••••••••••• <K12>
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Comms Power Table
|
||
;
|
||
; Tables of offsets to low level hardware dependent routines which are used for
|
||
; powering on and off the various communication ports, be they serial, modem, or Ethernet.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
ALIGN 4
|
||
DC.L PrimsTypePtr ; flags
|
||
DC.L (CommPowerTableEnd-CommsPowerTable) ; number of entries
|
||
CommsPowerTable
|
||
@PwrOn DC.L PortBOn-CommsPowerTable ; B serial
|
||
DC.L PortAOn-CommsPowerTable ; A serial
|
||
DC.L PortCOn-CommsPowerTable ; C serial (internal modem)
|
||
DC.L 0 ; no ethernet
|
||
|
||
@PwrOff DC.L PortBOff-CommsPowerTable ; B serial
|
||
DC.L PortAOff-CommsPowerTable ; A serial
|
||
DC.L PortCOff-CommsPowerTable ; C serial (internal modem)
|
||
DC.L 0 ; no ethernet
|
||
CommPowerTableEnd
|
||
|
||
with ModemTblRec
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; PortAOn - setup for port A use
|
||
;
|
||
;
|
||
; Input : d0 = bit 0: 0 = use internal modem, 1 = ignore internal modem
|
||
;
|
||
PortAOn
|
||
|
||
@savedregs reg d0-d3/a0-a2 ;
|
||
|
||
movem.l @savedregs,-(sp)
|
||
move.l d0,d2 ; d2 = indicator bits
|
||
|
||
move.l PmgrBase,a2 ; Get pmgr locals
|
||
bset #SerPortAPwr,PmgrFlags2(a2); set port a powered
|
||
|
||
; Check whether we should bypass the modem check
|
||
|
||
bclr.l #BypassModem,d0 ; set = ignore modem
|
||
bne.s @powerScc ; use the external ports
|
||
|
||
; check modem type
|
||
LoadTbl ModemTblPtr,a2,a0
|
||
beq.s @powerScc ; <K14>
|
||
JsrPrimTbl GetModemType,a0
|
||
cmpi.b #ModemTypeSerial,d0 ; is this a serial modem ?
|
||
bne.s @powerScc ; power on external port
|
||
|
||
; Modem is installed - read extended PRAM to see if modem should be powered on
|
||
|
||
MOVE.L #(1<<16)+(PmgrStatusFlags<<0),D0 ;
|
||
ADD.B PRAMBase(a2),D0 ; read the Power Manager flag byte
|
||
|
||
suba.w #2,sp ; alloc pmgr command pkt
|
||
movea.l sp,a0
|
||
_ReadXPRAM ; a0 = ptr to buf (writing over cmd word in pkt)
|
||
btst.b #UseIntrnlModem,(a0) ; check cdev bit for modem
|
||
adda.w #2,sp
|
||
bne @powerScc ; set - don't power modem
|
||
|
||
; Power on the modem
|
||
move.b #%00001000,d0 ; power on channel C
|
||
_SerialPower
|
||
|
||
move.b #(1<<ifCB2),([VIA],vIFR) ; clear interrupt flag reg
|
||
bset.b #6,([VIA],vPCR) ; change from neg to pos edge int
|
||
move.l MdmSndVect(A2),jModemSnd ; install sound on interrupt handler.
|
||
; Power on scc
|
||
@powerScc
|
||
bsr PowerSccOn ; turn on scc
|
||
|
||
@Done
|
||
movem.l (sp)+,@savedregs
|
||
rts
|
||
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; PortBOn - setup for port B use
|
||
;
|
||
;
|
||
; Input : d0 = bit 0: 0 = use internal modem, 1 = ignore internal modem
|
||
;
|
||
|
||
PortBOn bset #SerPortBPwr, \
|
||
([PMgrBase],PmgrFlags2) ; log power state
|
||
bsr PowerSccOn ; turn on scc
|
||
rts
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; PortCOn - setup for port C use
|
||
;
|
||
;
|
||
; Input : d0 = bit 0: 0 = use internal modem, 1 = ignore internal modem
|
||
;
|
||
|
||
PortCOn bset #SerPortCPwr, \
|
||
([PMgrBase],PmgrFlags2) ; log power state
|
||
bsr ModemPowerON ; power on modem
|
||
rts
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; PortAOff - release port a resources
|
||
;
|
||
;
|
||
|
||
PortAOff
|
||
|
||
@savedregs reg d0-d3/a0-a2 ;
|
||
|
||
movem.l @savedregs,-(sp)
|
||
move.l d0,d2 ; d2 = indicator bits
|
||
move.l PmgrBase,a2 ; Get pmgr locals
|
||
|
||
bclr.b #SerPortAPwr,PmgrFlags2(a2); read the Power Manager flag byte
|
||
|
||
; check modem type
|
||
LoadTbl ModemTblPtr,a2,a0
|
||
bne.s @powerOffScc ; <K14>
|
||
JsrPrimTbl GetModemType,a0
|
||
cmpi.b #ModemTypeSerial,d0 ; is this a serial modem ?
|
||
bne.s @powerOffScc ; power on external port
|
||
|
||
; Power off modem
|
||
move.b #%10001000,d0 ; power off channel C
|
||
_SerialPower
|
||
|
||
@powerOffScc
|
||
bsr HandleABPower ; power off scc if necessary
|
||
@Done
|
||
movem.l (sp)+,@savedregs
|
||
rts
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; PortBOff - release port a resources
|
||
;
|
||
;
|
||
|
||
PortBOff bclr.b #SerPortBPwr,\
|
||
([PMgrBase],PmgrFlags2) ; read the Power Manager flag byte
|
||
bsr HandleABPower
|
||
rts
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; PortCOn - setup for port C use
|
||
;
|
||
;
|
||
; Input : d0 = bit 0: 0 = use internal modem, 1 = ignore internal modem
|
||
;
|
||
|
||
PortCOff bclr #SerPortCPwr, \
|
||
([PMgrBase],PmgrFlags2) ; log power state
|
||
bsr ModemPowerOFF ; power on modem
|
||
rts
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; HandleABPower - given the current port usage, adjust power manager power control lines
|
||
;
|
||
;
|
||
|
||
HandleABPower
|
||
move.l d0,-(sp) ; save working set
|
||
move.b ([PMgrBase],PmgrFlags2),d0 ; get a copy of the flags
|
||
andi.b #((1<<SerPortAPwr) \ ; see if port A or B
|
||
+ (1<<SerPortBPwr)),d0 ; ... is currently in use
|
||
bne.s @done ; if non zero, then at least one is in use, exit
|
||
bsr PowerSccOff
|
||
@Done move.l (sp)+,d0
|
||
rts
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; SccOn/PowerSccOff - power control for SCC
|
||
;
|
||
;
|
||
; Power on scc
|
||
|
||
; power on scc
|
||
;
|
||
PowerSccOn
|
||
pSCCworkreg reg d0-d1/a0-a1
|
||
|
||
movem.l pSCCworkreg,-(sp)
|
||
moveq #0, d0
|
||
move.b #(sccOn|serOn), d0 ; load on command
|
||
bra.s SendCmd
|
||
|
||
; power off scc
|
||
;
|
||
PowerSccOff movem.l pSCCworkreg,-(sp)
|
||
moveq #0, d0
|
||
move.b #(sccOff|serOff),d0 ; load off command
|
||
; bra.s SendCmd
|
||
|
||
|
||
SendCmd
|
||
move.l d0, -(sp) ; data to send
|
||
move.l sp, -(sp) ; pmRBuffer
|
||
move.l 7(SP),-(sp) ; pmSBuffer
|
||
move.w #1, -(sp) ; pmLength
|
||
move.w #powerCntl,-(sp) ; pmCommand
|
||
MOVEA.L sp,a0 ; point to the parameter block
|
||
_PMgrOp ; get the modem info
|
||
move.l (sp), d0 ; return the status byte
|
||
adda.l #pmBlkSize, sp ; pop buffer
|
||
|
||
movem.l (sp)+,pSCCworkreg
|
||
rts
|
||
|
||
;——————————————————————————————————————————————————————————————————————————————————————— <K12>
|
||
; ModemPowerON/ModemPowerOFF - power control for modem slot
|
||
;
|
||
;
|
||
; Power on scc
|
||
; Power off modem
|
||
ModemPowerON
|
||
powerreg reg d0-d2/a0-a2
|
||
movem.l powerreg,-(sp) ; save working set
|
||
move.l #PowerOnModem,d2 ; load offset into modem primitives table for off
|
||
bra.s sendCommand
|
||
|
||
ModemPowerOFF
|
||
movem.l powerreg,-(sp) ; save working set
|
||
move.l #PowerOffModem,d2 ; load offset into modem primitives table for off
|
||
; bra.s sendCommand
|
||
|
||
sendCommand move.l PmgrBase,a2 ; Get pmgr locals
|
||
move.l vPMgrPrimitives(a2),d0 ; IF NoPrimitives THEN
|
||
beq.s @Done ; Exit
|
||
|
||
movea.l d0,a2 ; get pointer to primitives
|
||
move.l ModemTblPtr(a2),d0 ; get offset to ModemTblPtr
|
||
beq.s @Done ; Exit
|
||
|
||
move.l d0,-(sp)
|
||
bsr.l ModemStatusRT
|
||
move.l d0,d1 ; setup modem status for primitive routines
|
||
move.l (sp)+,d0
|
||
lea (a2,d0.L),a2 ; get pointer to ModemTblPtr
|
||
move.l (a2,d2.L),d0 ; load offset to routine
|
||
|
||
suba.w #pmBlkSize,sp ; alloc pmgr command pkt
|
||
lea pmData(sp),a0 ; get addr of buffer
|
||
move.l a0,pmRBuffer(sp) ; set ptr to rcv buffer
|
||
move.l a0,pmSBuffer(sp) ; set same ptr to xmit buffer (it's expected or error)
|
||
move.l sp,a0
|
||
jsr (a2,d0.L) ; Run the routine
|
||
adda.w #pmBlkSize,sp ; pop power mgr pkt
|
||
@Done
|
||
movem.l (sp)+,powerreg ; |
|
||
rts ; V
|
||
|
||
endwith ; {ModemTblRec}
|
||
END
|