mirror of
https://github.com/elliotnunn/sys7.1-doc-wip.git
synced 2024-05-31 13:41:30 +00:00
528 lines
14 KiB
C
528 lines
14 KiB
C
/*
|
|
File: I2C_Cyclone.c
|
|
|
|
Contains: This is the I2C component main code
|
|
|
|
Written by: Dan Hitchens
|
|
|
|
Copyright: © 1993 by Apple Computer, Inc., all rights reserved.
|
|
|
|
Change History (most recent first):
|
|
|
|
<SM3> 6/23/93 CSS Fix to work with ComponentFunctionProcPtr's.
|
|
<SM2> 6/14/93 kc Roll in Ludwig.
|
|
<LW2> 1/21/93 DH Fix so routines will transfer up to 256 bytes at a time until
|
|
all bytes are transfered.
|
|
|
|
*/
|
|
#include <Memory.h>
|
|
#include <Components.h>
|
|
#include <QTComponents.h>
|
|
#include "I2C_Cyclone.h"
|
|
#include "EgretEqu.h"
|
|
#include "CycloneDigi.h"
|
|
#include "I2C.h"
|
|
|
|
|
|
#define FALSE 0
|
|
#define TRUE 1
|
|
|
|
/* Uncomment this #define _BreakTime_ to cause a break at the start of every routine */
|
|
//#define _BreakTime_
|
|
|
|
/* private prototypes */
|
|
pascal ComponentResult InitI2CComponent(ComponentInstance self);
|
|
pascal ComponentResult ExitI2CComponent(Handle storage,ComponentInstance self);
|
|
pascal ComponentResult CanDoI2CSelector(short selector);
|
|
pascal ComponentResult GetI2CVersion(short *version);
|
|
pascal ComponentResult TargetComponent(Handle storage,ComponentInstance captureInstance);
|
|
unsigned char CudaI2C(unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char *data);
|
|
|
|
pascal ComponentResult SendIIC(Handle storage, unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char data);
|
|
pascal ComponentResult SendI2C(Handle storage, unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char *data);
|
|
pascal ComponentResult ReceiveI2C(Handle storage, unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char *data);
|
|
|
|
|
|
extern EgretGlu();
|
|
/* Implementation Section */
|
|
|
|
#define realComponent
|
|
#ifdef realComponent
|
|
pascal ComponentResult main( ComponentParameters *params, Handle storage )
|
|
#else
|
|
pascal ComponentResult I2CComponent( ComponentParameters *params, Handle storage )
|
|
#endif
|
|
{
|
|
|
|
short selector;
|
|
|
|
selector = params->what;
|
|
|
|
if (selector < 0) {
|
|
switch (selector) {
|
|
case kComponentOpenSelect :
|
|
return CallComponentFunction(params, (ComponentFunctionProcPtr)InitI2CComponent );
|
|
case kComponentCloseSelect :
|
|
return CallComponentFunctionWithStorage(storage, params, (ComponentFunctionProcPtr)ExitI2CComponent);
|
|
case kComponentCanDoSelect :
|
|
return CallComponentFunction(params, (ComponentFunctionProcPtr)CanDoI2CSelector);
|
|
case kComponentVersionSelect :
|
|
return CallComponentFunction(params, (ComponentFunctionProcPtr)GetI2CVersion);
|
|
case kComponentTargetSelect :
|
|
return CallComponentFunctionWithStorage(storage, params, (ComponentFunctionProcPtr)TargetComponent);
|
|
|
|
}
|
|
}
|
|
else {
|
|
switch (selector) {
|
|
case kI2CReadSelect :
|
|
return CallComponentFunctionWithStorage(storage, params, (ComponentFunctionProcPtr)tI2CRead);
|
|
case kI2CWriteSelect :
|
|
return CallComponentFunctionWithStorage(storage, params, (ComponentFunctionProcPtr)tI2CWrite);
|
|
case kI2CReadWithSubAddrSelect :
|
|
return CallComponentFunctionWithStorage(storage, params, (ComponentFunctionProcPtr)tI2CReadWithSubAddr);
|
|
case kI2CWriteWithSubAddrSelect :
|
|
return CallComponentFunctionWithStorage(storage, params, (ComponentFunctionProcPtr)tI2CWriteWithSubAddr);
|
|
}
|
|
};
|
|
}
|
|
|
|
pascal ComponentResult InitI2CComponent(ComponentInstance self) {
|
|
#pragma unused(self)
|
|
long Inst_Count,A5Value;
|
|
short ErrorNo;
|
|
Handle h,hs;
|
|
I2CGlobals *g;
|
|
//long refCon;
|
|
ComponentInstance t,Search_Inst;
|
|
ComponentDescription i2cThing;
|
|
long defType = 'i2c ';
|
|
long defSubType = 'm3tv';
|
|
long defManu = 'appl';
|
|
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered InitI2CComponent ");
|
|
#endif
|
|
|
|
/* allocate some private storage and lock it down */
|
|
h = NewHandle(sizeof(I2CGlobals));
|
|
if(h==nil) return(MemError());
|
|
MoveHHi(h);
|
|
HLock(h);
|
|
|
|
/* Initialize these fields to someComponent for now */
|
|
g = (I2CGlobals *)(*h);
|
|
|
|
g->gSelf = self; /*Save instance of self (incase we want to call ourself)*/
|
|
|
|
SetComponentInstanceStorage(self,h);
|
|
|
|
Inst_Count = CountComponentInstances((Component)self);
|
|
if(Inst_Count == 1)
|
|
{
|
|
/* Allocate storage for the Shadow Registers */
|
|
hs = NewHandleSys(sizeof(I2CShadow));
|
|
if(hs==nil) {
|
|
ErrorNo = MemError();
|
|
DisposeHandle(h);
|
|
return(ErrorNo);
|
|
}
|
|
MoveHHi(hs);
|
|
HLock(hs);
|
|
g->gShadowHandle = hs;
|
|
g->gShadowPtr = (I2CShadowPtr)*hs;
|
|
SetComponentRefcon((Component)self, (long)hs); /*Set the refcon to the handle to the shadow registers */
|
|
} else {
|
|
/*If there are already instances open, then we need to find the refcon from one that wasn't cloned */
|
|
|
|
/* First find an i2c thing and open it */
|
|
i2cThing.componentType = defType;
|
|
i2cThing.componentSubType = defSubType;
|
|
i2cThing.componentManufacturer = defManu;
|
|
i2cThing.componentFlags = 0x00L;
|
|
i2cThing.componentFlagsMask = 0x00L;
|
|
|
|
Search_Inst = 0x0L; /*Start by searching all */
|
|
do {
|
|
(Component)t = FindNextComponent((Component)Search_Inst,&i2cThing);
|
|
A5Value = GetComponentInstanceA5((ComponentInstance)t);
|
|
Search_Inst = t;
|
|
}
|
|
while ((A5Value != 0) && (t!=0));
|
|
/*Now suck down the RefCon (This is all for just incase we were cloned) */
|
|
(long)(g->gShadowHandle) = GetComponentRefcon((Component)t);
|
|
g->gShadowPtr = (I2CShadowPtr)*(g->gShadowHandle);
|
|
|
|
}
|
|
|
|
|
|
return (0);
|
|
}
|
|
|
|
pascal ComponentResult ExitI2CComponent(Handle storage,ComponentInstance self ) {
|
|
long Inst_Count;
|
|
I2CGlobals *g;
|
|
#pragma unused(self)
|
|
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered ExitI2CComponent ");
|
|
#endif
|
|
g = (I2CGlobals *)(*storage);
|
|
|
|
Inst_Count = CountComponentInstances((Component)self);
|
|
if(Inst_Count == 1) DisposeHandle(g->gShadowHandle);
|
|
|
|
|
|
DisposHandle(storage);
|
|
|
|
|
|
return(0);
|
|
}
|
|
|
|
pascal ComponentResult CanDoI2CSelector(short selector) {
|
|
long error = 0;
|
|
|
|
switch (selector)
|
|
{
|
|
case kComponentOpenSelect:
|
|
case kComponentCloseSelect:
|
|
case kComponentCanDoSelect:
|
|
case kComponentVersionSelect:
|
|
case kComponentTargetSelect:
|
|
|
|
case kI2CReadSelect :
|
|
case kI2CWriteSelect :
|
|
case kI2CReadWithSubAddrSelect :
|
|
case kI2CWriteWithSubAddrSelect :
|
|
error = 1;
|
|
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
pascal ComponentResult GetI2CVersion(short *version) {
|
|
|
|
*version = 0;
|
|
return (0);
|
|
}
|
|
pascal ComponentResult TargetComponent(Handle storage,ComponentInstance captureInstance) {
|
|
long error = 0;
|
|
I2CGlobals *g;
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered I2C TargetComponent");
|
|
#endif
|
|
|
|
g = (I2CGlobals *)(*storage);
|
|
g->gSelf = captureInstance;
|
|
|
|
return(error);
|
|
}
|
|
|
|
MakePString(short length, char *Source, char *Dest){
|
|
int j;
|
|
for (j=0; j<length; ++j) {
|
|
Dest[j] = Source[j];
|
|
}
|
|
return;
|
|
}
|
|
|
|
pascal ComponentResult tI2CRead (Handle storage, unsigned short slaveAddr, short byteCount, unsigned char *dataBuf) {
|
|
long error = 0;
|
|
I2CGlobals *g;
|
|
unsigned char *theBuffer;
|
|
short trans,transfered;
|
|
unsigned char myPString[257];
|
|
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered tI2CRead ");
|
|
#endif
|
|
|
|
g = (I2CGlobals *)(*storage);
|
|
// myPString[0] = 1; /*Set length of p-string to 1*/
|
|
|
|
|
|
/* NOTE: This will only return a maximum of one byte */
|
|
// error = ReceiveI2C(storage, 1, slaveAddr, 0, &myPString[0]);
|
|
// *dataBuf = myPString[0];
|
|
|
|
/*First make a P-string to use for ReceiveI2C call with the first byte equal to the max. no. of bytes to receive */
|
|
// if(byteCount==256) myPString[0] = 0; else myPString[0] = byteCount;
|
|
|
|
// error = ReceiveI2C(storage, 1, slaveAddr, 0, &myPString[0]);
|
|
/* Now copy the data out of the p-string back to the dataBuf */
|
|
// MakePString(byteCount,&myPString[1],dataBuf);
|
|
|
|
|
|
|
|
theBuffer = dataBuf;
|
|
transfered = byteCount;
|
|
do {
|
|
if(transfered >= 256) {
|
|
myPString[0] = 0; /*transfer 256 bytes*/
|
|
trans = 256;
|
|
}
|
|
else {
|
|
myPString[0] = transfered;
|
|
trans = transfered;
|
|
}
|
|
|
|
transfered -= 256;
|
|
|
|
error = ReceiveI2C(storage, 1, slaveAddr, 0, &myPString[0]);
|
|
MakePString(trans, &myPString[1], theBuffer);
|
|
theBuffer +=256;
|
|
|
|
} while ((error==0) && (transfered>0)); /*Do until an error occurs or weve transferred all the data 256 bytes at a time*/
|
|
|
|
|
|
|
|
return(error);
|
|
}
|
|
|
|
pascal ComponentResult tI2CWrite (Handle storage, unsigned short slaveAddr, short byteCount, unsigned char *dataBuf){
|
|
long error = 0;
|
|
I2CGlobals *g;
|
|
unsigned char *theBuffer;
|
|
short trans,transfered;
|
|
unsigned char myPString[257];
|
|
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered tI2CWrite ");
|
|
#endif
|
|
|
|
g = (I2CGlobals *)(*storage);
|
|
|
|
theBuffer = dataBuf;
|
|
transfered = byteCount;
|
|
do {
|
|
if(transfered >= 256) {
|
|
myPString[0] = 0; /*transfer 256 bytes*/
|
|
trans = 256;
|
|
}
|
|
else {
|
|
myPString[0] = transfered;
|
|
trans = transfered;
|
|
}
|
|
|
|
transfered -= 256;
|
|
|
|
MakePString(trans, theBuffer, &myPString[1]);
|
|
error = SendI2C(storage, 1, slaveAddr, 0, &myPString);
|
|
theBuffer +=256;
|
|
|
|
} while ((error==0) && (transfered>0)); /*Do until an error occurs or weve transferred all the data 256 bytes at a time*/
|
|
|
|
return(error);
|
|
}
|
|
|
|
pascal ComponentResult tI2CReadWithSubAddr (Handle storage, unsigned short slaveAddr, unsigned short subAddr, short byteCount, unsigned char *dataBuf) {
|
|
long error = 0;
|
|
I2CGlobals *g;
|
|
unsigned char *theBuffer;
|
|
short trans,transfered;
|
|
unsigned short XSubAddr;
|
|
unsigned char myPString[257];
|
|
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered tI2CReadWithSubAddr ");
|
|
#endif
|
|
|
|
g = (I2CGlobals *)(*storage);
|
|
|
|
/*First make a P-string to use for ReceiveI2C call with the first byte equal to the max. no. of bytes to receive */
|
|
// if(byteCount==256) myPString[0] = 0; else myPString[0] = byteCount;
|
|
|
|
// error = ReceiveI2C(storage, 2, slaveAddr, subAddr, &myPString[0]);
|
|
/* Now copy the data out of the p-string back to the dataBuf */
|
|
// MakePString(byteCount,&myPString[1],dataBuf);
|
|
|
|
theBuffer = dataBuf;
|
|
transfered = byteCount;
|
|
XSubAddr = subAddr;
|
|
do {
|
|
if(transfered >= 256) {
|
|
myPString[0] = 0; /*transfer 256 bytes*/
|
|
trans = 256;
|
|
}
|
|
else {
|
|
myPString[0] = transfered;
|
|
trans = transfered;
|
|
}
|
|
|
|
transfered -= 256;
|
|
|
|
error = ReceiveI2C(storage, 2, slaveAddr, XSubAddr, &myPString[0]);
|
|
MakePString(trans, &myPString[1], theBuffer);
|
|
theBuffer +=256;
|
|
XSubAddr +=256;
|
|
|
|
} while ((error==0) && (transfered>0)); /*Do until an error occurs or weve transferred all the data 256 bytes at a time*/
|
|
|
|
|
|
return(error);
|
|
}
|
|
|
|
pascal ComponentResult tI2CWriteWithSubAddr (Handle storage, unsigned short slaveAddr, unsigned short subAddr, short byteCount, unsigned char *dataBuf) {
|
|
long error = 0;
|
|
I2CGlobals *g;
|
|
unsigned char *theBuffer;
|
|
short trans,transfered;
|
|
unsigned short XSubAddr;
|
|
unsigned char myPString[257];
|
|
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered tI2CWriteWithSubAddr ");
|
|
#endif
|
|
|
|
g = (I2CGlobals *)(*storage);
|
|
|
|
theBuffer = dataBuf;
|
|
transfered = byteCount;
|
|
XSubAddr = subAddr;
|
|
do {
|
|
if(transfered >= 256) {
|
|
myPString[0] = 0; /*transfer 256 bytes*/
|
|
trans = 256;
|
|
}
|
|
else {
|
|
myPString[0] = transfered;
|
|
trans = transfered;
|
|
}
|
|
|
|
transfered -= 256;
|
|
|
|
MakePString(trans, theBuffer, &myPString[1]);
|
|
error = SendI2C(storage, 2, slaveAddr, XSubAddr, &myPString);
|
|
theBuffer +=256;
|
|
XSubAddr +=256;
|
|
|
|
} while ((error==0) && (transfered>0)); /*Do until an error occurs or weve transferred all the data 256 bytes at a time*/
|
|
|
|
return(error);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pascal ComponentResult SendIIC(Handle storage, unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char data){
|
|
I2CGlobals *g;
|
|
Str255 myPString;
|
|
long error;
|
|
g = (I2CGlobals *)(*storage);
|
|
myPString[0] = 1;
|
|
myPString[1] = data;
|
|
|
|
error = SendI2C(storage, noBytes, slaveAddr, subAddr, &myPString);
|
|
return(error);
|
|
|
|
}
|
|
|
|
pascal ComponentResult SendI2C(Handle storage, unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char *data){
|
|
I2CGlobals *g;
|
|
short i,sub;
|
|
short len;
|
|
|
|
g = (I2CGlobals *)(*storage);
|
|
|
|
|
|
CudaI2C(noBytes, slaveAddr, subAddr, data); /* Call cuda to actually send the data */
|
|
|
|
len = data[0]; /*gets the length*/
|
|
if (len == 0) len = 256;
|
|
sub = subAddr;
|
|
|
|
/*Now shadow the value */
|
|
if ((slaveAddr == kDMSD_Chip)&&(subAddr <= 0x18)) {
|
|
for (i=1; i<len+1; ++i) {
|
|
g->gShadowPtr->gDMSDRec[sub] = data[i];
|
|
++sub;
|
|
}
|
|
}
|
|
if ((slaveAddr == kVDC_Chip) && (subAddr <= 0x10)) {
|
|
for (i=1; i<len+1; ++i) {
|
|
g->gShadowPtr->gVDCRec[sub] = data[i];
|
|
++sub;
|
|
}
|
|
}
|
|
return(0);
|
|
|
|
}
|
|
pascal ComponentResult ReceiveI2C(Handle storage, unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char *data){
|
|
I2CGlobals *g;
|
|
short i,sub;
|
|
short len;
|
|
|
|
g = (I2CGlobals *)(*storage);
|
|
|
|
#ifdef _BreakTime_
|
|
DebugStr("\pEntered ReceiveI2c Routine, LOOK OuTTTTTTTTT ;hc ");
|
|
#endif
|
|
|
|
len = data[0]; /*gets the length*/
|
|
if (len == 0) len = 256;
|
|
sub = subAddr;
|
|
|
|
/*Now see if its one of our shadowed the value */
|
|
if ((slaveAddr == kDMSD_Chip) && (noBytes ==2) && (subAddr <= 0x18)) {
|
|
if(len>0x19) len = 0x19;
|
|
for (i=1; i<len+1; ++i) {
|
|
data[i] = g->gShadowPtr->gDMSDRec[sub];
|
|
++sub;
|
|
}
|
|
data[0]=len;
|
|
return(0);
|
|
}
|
|
|
|
if ((slaveAddr == kVDC_Chip) && (noBytes ==2) && (subAddr <= 0x0f)) {
|
|
if(len>0x10) len = 0x10;
|
|
for (i=1; i<len+1; ++i) {
|
|
data[i] = g->gShadowPtr->gVDCRec[sub];
|
|
++sub;
|
|
}
|
|
data[0]=len;
|
|
return(0);
|
|
}
|
|
|
|
CudaI2C(noBytes,slaveAddr, subAddr, data); /* Receive i2c block */
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
//*****************************************************************************************
|
|
// CudaI2C
|
|
//
|
|
// Send Cmd to Cuda FW to begin to send/receive I2C Data to/from Slave
|
|
//*****************************************************************************************
|
|
//
|
|
unsigned char CudaI2C(unsigned char noBytes, unsigned char slaveAddr, unsigned char subAddr, unsigned char *data)
|
|
{
|
|
EgretPB myCudaPB; /* Cuda parameter block */
|
|
|
|
|
|
myCudaPB.pbCmdType = pseudoPkt; // CmdType
|
|
myCudaPB.pbCmd = 0x22; // Cmd -> Write IIC data (was WrIIc ddh)
|
|
myCudaPB.pbParm.pbbyte[0] = slaveAddr; // Slave Addr -> IIC (send I2c if even, receive if odd)
|
|
myCudaPB.pbParm.pbbyte[1] = subAddr; // Slave Reg -> IIC
|
|
|
|
myCudaPB.pbParm.pbbyte[2] = 0; // Data -> IIC (was data ddh)
|
|
myCudaPB.pbParm.pbbyte[3] = 0; // clr
|
|
myCudaPB.pbByteCnt = noBytes; // Number of bytes to send
|
|
myCudaPB.pbBufPtr = data; // (Was zero, DDH)
|
|
|
|
/* Make sure these are all zero */
|
|
myCudaPB.pbFlags = 0;
|
|
myCudaPB.pbSpareFlags = 0;
|
|
myCudaPB.pbResult = 0;
|
|
myCudaPB.pbCompletion = 0;
|
|
|
|
/* Debugger();*/
|
|
EgretGlu(&myCudaPB);
|
|
// NOTE: data is now returned in the passed p-string area, not as a returned parameter. DDH
|
|
return(myCudaPB.pbResult); /* return error if any*/
|
|
}
|