diff options
Diffstat (limited to '')
-rw-r--r-- | private/ntos/ndis/digi/pcimac/idd_init.c | 894 |
1 files changed, 894 insertions, 0 deletions
diff --git a/private/ntos/ndis/digi/pcimac/idd_init.c b/private/ntos/ndis/digi/pcimac/idd_init.c new file mode 100644 index 000000000..54cb548aa --- /dev/null +++ b/private/ntos/ndis/digi/pcimac/idd_init.c @@ -0,0 +1,894 @@ +/* + * IDD_INIT.C - IDD initialization + */ + +#include <ndis.h> +#include <ndiswan.h> +#include <ndistapi.h> +#include <mytypes.h> +#include <mydefs.h> +#include <disp.h> +#include <util.h> +#include <opcodes.h> +#include <adapter.h> +#include <idd.h> +#include <mtl.h> +#include <cm.h> +#include <res.h> +#include <trc.h> +#include <io.h> + +#include <ansihelp.h> + + +typedef struct +{ + NDIS_SPIN_LOCK lock; + ULONG NumberOfIddsInSystem; + ULONG LastIddPolled; + ADAPTER *CurrentAdapter; + ADAPTER *LastAdapter; + IDD* Idd[MAX_IDD_IN_SYSTEM]; +}IDD_TABLE; + +IDD_TABLE GlobalIddTbl; + +BOOLEAN IsThisAdapterNext(ADAPTER *Adapter); + +/* driver global vars */ +extern DRIVER_BLOCK Pcimac; + +ULONG EnumIddInSystem() +{ + ULONG NumberOfIddsInSystem; + + NdisAcquireSpinLock(&GlobalIddTbl.lock); + + NumberOfIddsInSystem = GlobalIddTbl.NumberOfIddsInSystem; + + NdisReleaseSpinLock(&GlobalIddTbl.lock); + + return(NumberOfIddsInSystem); +} + +IDD* GetIddByIndex( ULONG Index ) +{ + IDD *idd; + + NdisAcquireSpinLock(&GlobalIddTbl.lock); + + idd = GlobalIddTbl.Idd[Index]; + + NdisReleaseSpinLock(&GlobalIddTbl.lock); + + return(idd); +} + +ULONG +EnumIddPerAdapter( + VOID *Adapter_1 + ) +{ + ADAPTER *Adapter = (ADAPTER*)Adapter_1; + + return(Adapter->NumberOfIddOnAdapter); +} + + +INT +IoEnumIdd(VOID *cmd_1) +{ + ULONG n; + IO_CMD *cmd = (IO_CMD*)cmd_1; + + NdisAcquireSpinLock(&GlobalIddTbl.lock); + + cmd->val.enum_idd.num = (USHORT)GlobalIddTbl.NumberOfIddsInSystem; + + for (n = 0; n < GlobalIddTbl.NumberOfIddsInSystem; n++) + { + IDD *idd; + + idd = cmd->val.enum_idd.tbl[n] = GlobalIddTbl.Idd[n]; + + NdisMoveMemory(&cmd->val.enum_idd.name[n], + idd->name, + sizeof(cmd->val.enum_idd.name[n])); + } + + NdisReleaseSpinLock(&GlobalIddTbl.lock); + + return(0); +} + +#pragma NDIS_INIT_FUNCTION(idd_init) + +ULONG +idd_init(VOID) +{ + // + // clear out idd table + // + NdisZeroMemory(&GlobalIddTbl, sizeof(IDD_TABLE)); + + NdisAllocateSpinLock(&GlobalIddTbl.lock); + + return(IDD_E_SUCC); +} + +#pragma NDIS_INIT_FUNCTION(idd_create) + +/* allocate & initialize an idd object */ +INT +idd_create(VOID **ret_idd, USHORT btype) +{ + IDD *idd; + INT n; + NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1); + + D_LOG(D_ENTRY, ("idd_create: BoardType: %d\n", btype)); + + /* allocate memory object */ + NdisAllocateMemory((PVOID*)&idd, sizeof(IDD), 0, pa); + if ( !idd ) + { + D_LOG(DIGIINIT, ("idd_create: memory allocate failed!\n")); + return(IDD_E_NOMEM); + } + + NdisAcquireSpinLock(&GlobalIddTbl.lock); + + // + // store idd in system idd table + // + for (n = 0; n < MAX_IDD_IN_SYSTEM; n++) + if (!GlobalIddTbl.Idd[n]) + break; + + if (n >= MAX_IDD_IN_SYSTEM) + { + // + // We are unable to find an empty slot for the IDD object. + // + /* free memory for idd */ + NdisFreeMemory(idd, sizeof(*idd), 0); + + NdisReleaseSpinLock(&GlobalIddTbl.lock); + + return(IDD_E_NOROOM); + } + + GlobalIddTbl.Idd[n] = idd; + GlobalIddTbl.NumberOfIddsInSystem++; + + NdisReleaseSpinLock(&GlobalIddTbl.lock); + + D_LOG(DIGIINIT, ("idd_create: idd: 0x%lx\n", idd)); + NdisZeroMemory(idd, sizeof(IDD)); + + /* setup init state, adapter handle */ + idd->state = IDD_S_INIT; + idd->trc = NULL; + + /* allocate root spinlock */ + NdisAllocateSpinLock(&idd->lock); + + /* initialize send queues */ + for( n = 0 ; n < IDD_TX_PORTS ; n++ ) + { + INT max; + + /* initialize queue */ + idd->sendq[n].max = max = IDD_MAX_SEND / IDD_TX_PORTS; + + idd->sendq[n].tbl = idd->smsg_pool + max * n; + + /* allocate spin lock */ + NdisAllocateSpinLock(&idd->sendq[n].lock); + } + + /* initialize receiver tables */ + for ( n = 0 ; n < IDD_RX_PORTS ; n++ ) + { + INT max; + + /* initialize table */ + idd->recit[n].max = max = IDD_MAX_HAND / IDD_RX_PORTS; + idd->recit[n].tbl = idd->rhand_pool + max * n; + + /* allocate spin lock */ + NdisAllocateSpinLock(&idd->recit[n].lock); + } + + /* initialize board specific functions */ + switch ( btype ) + { + case IDD_BT_PCIMAC : + idd->SetBank = (VOID*)IdpPcSetBank; + idd->SetPage = (VOID*)IdpPcSetPage; + idd->SetBasemem = (VOID*)IdpPcSetBasemem; + idd->CheckIO = (VOID*)IdpCheckIO; + idd->CheckMem = (VOID*)IdpCheckMem; + idd->LoadCode = (VOID*)IdpLoadCode; + idd->PollTx = (VOID*)IdpPollTx; + idd->PollRx = (VOID*)IdpPollRx; + idd->Execute = (VOID*)IdpExec; + idd->OutToPort = (VOID*)IdpOutp; + idd->InFromPort = (VOID*)IdpInp; + idd->ApiGetPort = (VOID*)IdpGetPort; + idd->ApiBindPort = (VOID*)IdpBindPort; + idd->ApiAllocBuffer = (VOID*)IdpAllocBuf; + idd->ResetAdapter = (VOID*)IdpResetBoard; + idd->NVRamRead = (VOID*)IdpNVRead; + idd->ChangePage = (VOID*)IdpCPage; + break; + + case IDD_BT_PCIMAC4 : + idd->SetBank = (VOID*)IdpPc4SetBank; + idd->SetPage = (VOID*)IdpPc4SetPage; + idd->SetBasemem = (VOID*)IdpPc4SetBasemem; + idd->CheckIO = (VOID*)IdpCheckIO; + idd->CheckMem = (VOID*)IdpCheckMem; + idd->LoadCode = (VOID*)IdpLoadCode; + idd->PollTx = (VOID*)IdpPollTx; + idd->PollRx = (VOID*)IdpPollRx; + idd->Execute = (VOID*)IdpExec; + idd->OutToPort = (VOID*)IdpOutp; + idd->InFromPort = (VOID*)IdpInp; + idd->ApiGetPort = (VOID*)IdpGetPort; + idd->ApiBindPort = (VOID*)IdpBindPort; + idd->ApiAllocBuffer = (VOID*)IdpAllocBuf; + idd->ResetAdapter = (VOID*)IdpResetBoard; + idd->NVRamRead = (VOID*)IdpNVRead; + idd->ChangePage = (VOID*)IdpCPage; + break; + + case IDD_BT_MCIMAC : + idd->SetBank = (VOID*)IdpMcSetBank; + idd->SetPage = (VOID*)IdpMcSetPage; + idd->SetBasemem = (VOID*)IdpMcSetBasemem; + idd->CheckIO = (VOID*)IdpCheckIO; + idd->CheckMem = (VOID*)IdpCheckMem; + idd->LoadCode = (VOID*)IdpLoadCode; + idd->PollTx = (VOID*)IdpPollTx; + idd->PollRx = (VOID*)IdpPollRx; + idd->Execute = (VOID*)IdpExec; + idd->OutToPort = (VOID*)IdpOutp; + idd->InFromPort = (VOID*)IdpInp; + idd->ApiGetPort = (VOID*)IdpGetPort; + idd->ApiBindPort = (VOID*)IdpBindPort; + idd->ApiAllocBuffer = (VOID*)IdpAllocBuf; + idd->ResetAdapter = (VOID*)IdpResetBoard; + idd->NVRamRead = (VOID*)IdpNVRead; + idd->ChangePage = (VOID*)IdpCPage; + break; + + case IDD_BT_DATAFIREU : + case IDD_BT_DATAFIREST: + case IDD_BT_DATAFIRE4ST: + idd->SetBank = (VOID*)AdpSetBank; + idd->SetPage = (VOID*)AdpSetPage; + idd->SetBasemem = (VOID*)AdpSetBasemem; + idd->CheckIO = (VOID*)AdpCheckIO; + idd->CheckMem = (VOID*)AdpCheckMem; + idd->LoadCode = (VOID*)AdpLoadCode; + idd->PollTx = (VOID*)AdpPollTx; + idd->PollRx = (VOID*)AdpPollRx; + idd->Execute = (VOID*)AdpExec; + idd->OutToPort = (VOID*)AdpOutp; + idd->InFromPort = (VOID*)AdpInp; + idd->ApiGetPort = (VOID*)AdpGetPort; + idd->ApiBindPort = (VOID*)AdpBindPort; + idd->ApiAllocBuffer = (VOID*)AdpAllocBuf; + idd->ResetAdapter = (VOID*)AdpResetBoard; + idd->NVRamRead = (VOID*)AdpNVRead; + idd->ChangePage = (VOID*)AdpCPage; + break; + } + + + /* init sema */ + sema_init(&idd->proc_sema); + + // + // attach idd frame detection handlers + // these must be attached 1st for all data handlers + // + idd_attach(idd, IDD_PORT_B1_RX, (VOID*)DetectFramingHandler, idd); + idd_attach(idd, IDD_PORT_B2_RX, (VOID*)DetectFramingHandler, idd); + + // attach a command handler to get area info from idp + idd_attach (idd, IDD_PORT_CMD_RX, (VOID*)idd__cmd_handler, idd); + + /* return address & success */ + *ret_idd = idd; + D_LOG(D_EXIT, ("idd_create: exit\n")); + return(IDD_E_SUCC); +} + +/* free idd object */ +INT +idd_destroy(VOID *idd_1) +{ + IDD *idd = (IDD*)idd_1; + INT n; + + D_LOG(D_ENTRY, ("idd_destroy: entry, idd: 0x%lx\n", idd)); + + // detach command handler from this idd + idd_detach (idd, IDD_PORT_CMD_RX, (VOID*)idd__cmd_handler, idd); + + /* perform a shutdown (maybe null) */ + idd_shutdown(idd); + + /* if file handle for binary file open, close it */ + if ( idd->phw.fbin ) + NdisCloseFile(idd->phw.fbin); + + /* free spin locks for send queue */ + for ( n = 0 ; n < IDD_TX_PORTS ; n++ ) + NdisFreeSpinLock(&idd->sendq[n].lock); + + /* free spin locks for reciever tables */ + for ( n = 0 ; n < IDD_RX_PORTS ; n++ ) + NdisFreeSpinLock(&idd->recit[n].lock); + + /* free resource handles */ + if ( idd->res_io != NULL) + res_destroy(idd->res_io); + + if ( idd->res_mem != NULL) + res_destroy(idd->res_mem); + + // free trc object + if (idd->trc != NULL) + { + trc_deregister_idd(idd); + trc_destroy (idd->trc); + } + + /* term sema */ + sema_term(&idd->proc_sema); + + /* free spinlock (while allocated!) */ + NdisFreeSpinLock(&idd->lock); + + NdisAcquireSpinLock(&GlobalIddTbl.lock); + + // + // store idd in system idd table + // + for (n = 0; n < MAX_IDD_IN_SYSTEM; n++) + if (GlobalIddTbl.Idd[n] == idd) + break; + + if (n < MAX_IDD_IN_SYSTEM) + GlobalIddTbl.Idd[n] = NULL; + + GlobalIddTbl.NumberOfIddsInSystem--; + + NdisReleaseSpinLock(&GlobalIddTbl.lock); + + /* free memory for idd */ + NdisFreeMemory(idd, sizeof(*idd), 0); + + + /* return success */ + D_LOG(D_EXIT, ("idd_destroy: exit\n")); + return(IDD_E_SUCC); +} + + +//#ifdef PERADAPTER + +VOID +IddPollFunction( + VOID *a1, + VOID *Adapter_1, + VOID *a3, + VOID *a4 + ) +{ +#define MAX_EVENTS 1000 + ULONG i, j, EventNum, TotalEventNum = 0; + ULONG FirstIdd, NumberOfIddOnAdapter; + ADAPTER *Adapter = (ADAPTER*)Adapter_1; + IDD *idd; + + // + // check to see if there is someone else already polling + // an adapter that has the same shared memory window + // as this adapter. if someone is then get out so that we + // don't burn up this processor waiting for the other to complete + // if this adapter is supposed to be the next adapter to be polled + // only send him away for awhile, else send him away for normal polling + // time + // + if (CheckInDriverFlag(Adapter)) + { + if (IsThisAdapterNext(Adapter)) + { + // + // we want to come back asap + // + NdisMSetTimer(&Adapter->IddPollTimer, 0); + } + else + { + // + // we want to come back at our regular time + // + NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T); + } + return; + } + + SetInDriverFlag(Adapter); + + // + // this will be the first idd that we will poll + // + FirstIdd = Adapter->LastIddPolled; + + // + // this will be the number of idds that we will poll + // + NumberOfIddOnAdapter = Adapter->NumberOfIddOnAdapter; + + do + { + EventNum = 0; + + // + // we will service all of the idd's in the system + // first lets do some receives + // + + for (i = FirstIdd, j = FirstIdd + NumberOfIddOnAdapter; i < j; i++) + { + idd = Adapter->IddTbl[i % NumberOfIddOnAdapter]; + + if (idd && (idd->state == IDD_S_RUN)) + EventNum += idd->PollRx(idd); + } + + + // + // we will service all of the idd's in the system + // now lets do the send queue + // + for (i = FirstIdd, j = FirstIdd + NumberOfIddOnAdapter; i < j; i++) + { + idd = Adapter->IddTbl[i % NumberOfIddOnAdapter]; + + if (idd && (idd->state == IDD_S_RUN)) + { + EventNum += idd->PollTx(idd); + EventNum += idd->PollRx(idd); + } + } + + TotalEventNum += EventNum; + + } while (EventNum && (TotalEventNum < MAX_EVENTS) ); + + // + // bump so we start at next idd next time + // + Adapter->LastIddPolled++; + + if (Adapter->LastIddPolled == NumberOfIddOnAdapter) + Adapter->LastIddPolled = 0; + + ClearInDriverFlag(Adapter); + + NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T); + + // + // lets go ahead and give some of this data up to the wrapper + // hopefully this will keep us from running out of room in our + // assembly descriptor table + // + TryToIndicateMtlReceives(Adapter); +} + +//#endif + +BOOLEAN +IsThisAdapterNext( + ADAPTER *Adapter + ) +{ + BOOLEAN ThisIsIt = FALSE; + + NdisAcquireSpinLock(&Pcimac.lock); + + if (Adapter == Pcimac.AdapterTbl[Pcimac.NextAdapterToPoll]) + ThisIsIt = TRUE; + + NdisReleaseSpinLock(&Pcimac.lock); + + return(ThisIsIt); +} + + +#ifdef ALLADAPTERS +VOID +IddPollFunction( + VOID *a1, + VOID *Adapter_1, + VOID *a3, + VOID *a4 + ) +{ +#define MAX_EVENTS 1000 + ULONG i, j, EventNum, TotalEventNum = 0; + ULONG FirstIdd, NumberOfIddsInSystem; + ADAPTER *Adapter = (ADAPTER*)Adapter_1; + IDD *idd; + + + NdisAcquireSpinLock(&GlobalIddTbl.lock); + + GlobalIddTbl.LastAdapter = GlobalIddTbl.CurrentAdapter; + + GlobalIddTbl.CurrentAdapter = Adapter; + + // + // this will be the first idd that we will poll + // + FirstIdd = GlobalIddTbl.LastIddPolled; + + // + // this will be the number of idds that we will poll + // + NumberOfIddsInSystem = GlobalIddTbl.NumberOfIddsInSystem; + + do + { + EventNum = 0; + + // + // we will service all of the idd's in the system + // first lets do some receives + // + for (i = FirstIdd, j = FirstIdd + NumberOfIddsInSystem; i < j; i++) + { + idd = GlobalIddTbl.Idd[i % NumberOfIddsInSystem]; + + if (idd->state == IDD_S_RUN) + EventNum += idd->PollRx(idd); + } + + // + // we will service all of the idd's in the system + // now lets do the send queue + // + for (i = FirstIdd, j = FirstIdd + NumberOfIddsInSystem; i < j; i++) + { + idd = GlobalIddTbl.Idd[i % NumberOfIddsInSystem]; + + if (idd->state == IDD_S_RUN) + { + EventNum += idd->PollTx(idd); + EventNum += idd->PollRx(idd); + } + } + + TotalEventNum += EventNum; + + } while (EventNum && (TotalEventNum < MAX_EVENTS) ); + + GlobalIddTbl.LastIddPolled++; + + if (GlobalIddTbl.LastIddPolled == NumberOfIddsInSystem) + GlobalIddTbl.LastIddPolled = 0; + + NdisReleaseSpinLock(&GlobalIddTbl.lock); + + // + // lets go ahead and give some of this data up to the wrapper + // hopefully this will keep us from running out of room in our + // assembly descriptor table + // +// TryToIndicateMtlReceives(Adapter); + + NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T); +} + +#endif + +#ifdef OLD +VOID +IddPollFunction( + VOID *a1, + VOID *Adapter_1, + VOID *a3, + VOID *a4 + ) +{ +#define MAX_EVENTS 1000 + ULONG n, EventNum, TotalEventNum = 0; + + ADAPTER *Adapter = (ADAPTER*)Adapter_1; + + do + { + EventNum = 0; + + // + // we will service all of the idd's in the system + // first lets do some receives + // + for (n = 0; n < MAX_IDD_IN_SYSTEM; n++) + { + IDD *idd = GlobalIddTbl[n]; + + if (idd && (idd->state == IDD_S_RUN)) + EventNum += idd->PollRx(idd); + } + + // + // we will service all of the idd's in the system + // now lets do the send queue + // + for (n = 0; n < MAX_IDD_IN_SYSTEM; n++) + { + IDD *idd = GlobalIddTbl[n]; + + if (idd && (idd->state == IDD_S_RUN)) + EventNum += idd->PollTx(idd); + } + + TotalEventNum += EventNum; + + } while (EventNum && (TotalEventNum < MAX_EVENTS) ); + + // + // lets go ahead and give some of this data up to the wrapper + // hopefully this will keep us from running out of room in our + // assembly descriptor table + // +// TryToIndicateMtlReceives(Adapter); + + NdisMSetTimer(&Adapter->IddPollTimer, IDD_POLL_T); +} +#endif + +/* get idd name */ +CHAR* +idd_get_name(VOID *idd_1) +{ + IDD *idd = (IDD*)idd_1; + return(idd->name); +} + +USHORT +idd_get_bline(VOID *idd_1) +{ + IDD *idd = (IDD*)idd_1; + return(idd->bline); +} + +USHORT +idd_get_btype(VOID *idd_1) +{ + IDD *idd = (IDD*)idd_1; + return(idd->btype); +} + +VOID* +idd_get_trc (VOID *idd_1) +{ + IDD *idd = (IDD*)idd_1; + return(idd->trc); +} + +VOID +idd_set_trc (VOID *idd_1, TRC* Trace) +{ + IDD *idd = (IDD*)idd_1; + idd->trc = Trace; +} + +INT +idd_reset_area (VOID* idd_1) +{ + IDD *idd = (IDD*)idd_1; + + idd->Area.area_state = AREA_ST_IDLE; + + return(IDD_E_SUCC); +} + +INT +idd_get_area_stat (VOID *idd_1, IDD_AREA *IddStat) +{ + IDD *idd = (IDD*)idd_1; + + *IddStat = idd->Area; + + return(IDD_E_SUCC); +} + + +/* get an idd area (really start operation, complete on handler callback) */ +INT +idd_get_area(VOID *idd_1, ULONG area_id, VOID (*handler)(), VOID *handler_arg) +{ + IDD *idd = (IDD*)idd_1; + IDD_MSG msg; + + D_LOG(D_ENTRY, ("idd_get_area: entry, idd: 0x%lx, area_id: %ld\n", idd, area_id)); + D_LOG(D_ENTRY, ("idd_get_area: handler: 0x%lx, handler_arg: 0x%lx\n", handler, handler_arg)); + + /* check if area is not busy */ + if ( idd->Area.area_state == AREA_ST_PEND ) + return(IDD_E_BUSY); + + /* mark area is pending, store arguments */ + idd->Area.area_state = AREA_ST_PEND; + idd->Area.area_id = area_id; + idd->Area.area_idd = idd; + idd->Area.area_len = 0; + idd->Area.area_handler = handler; + idd->Area.area_handler_arg = handler_arg; + + /* issue idd command to get area */ + NdisZeroMemory(&msg, sizeof(msg)); + msg.opcode = CMD_DUMP_PARAM; + msg.param = msg.bufid = area_id; + if ( idd_send_msg(idd, &msg, IDD_PORT_CMD_TX, NULL, NULL) != IDD_E_SUCC ) + { + /* idd op failed! */ + idd->Area.area_state = AREA_ST_IDLE; + return(IDD_E_AREA); + } + + /* succ here */ + return(IDD_E_SUCC); +} + +VOID +IddSetRxFraming( + IDD *idd, + USHORT bchan, + ULONG FrameType + ) +{ + idd->recit[bchan].RxFrameType = FrameType; +} + +VOID +DetectFramingHandler( + IDD *idd, + USHORT port, + ULONG RxFrameType, + IDD_XMSG *msg + ) +{ + UCHAR DetectBytes[2]; + + DigiDump( DIGIQ931, ("DetectFramingHandler: idd = 0x%x, port = 0x%x, RxFrameType = 0x%x, msg = 0x%x\n", + idd, + port, + RxFrameType, + msg) ); + + if (RxFrameType & IDD_FRAME_DETECT) + { + // + // get detection bytes + // + IddGetDataFromAdapter(idd, + (PUCHAR)&DetectBytes, + (PUCHAR)msg->bufptr, + 2); + +// NdisMoveMemory ((PUCHAR)&DetectBytes, (PUCHAR)msg->bufptr, 2); + + D_LOG(D_ENTRY, ("DetectRxFraming: 0x%x, 0x%x\n",DetectBytes[0], DetectBytes[1])); + + if ((DetectBytes[0] == DKF_UUS_SIG) && (!DetectBytes[1])) + idd->recit[port].RxFrameType = IDD_FRAME_DKF; + + else if ((DetectBytes[0] == PPP_SIG_0) && (DetectBytes[1] == PPP_SIG_1)) + { + idd->recit[port].RxFrameType = IDD_FRAME_PPP; + cm__ppp_conn(idd, port); + } + } +} + +VOID +idd__cmd_handler(IDD *idd, USHORT chan, ULONG Reserved, IDD_MSG *msg) +{ + ULONG bytes; + + /* check for show area more/last frames (3/4) */ + if ( msg->bufid >= 2 ) + { + if ( (idd->Area.area_state == AREA_ST_PEND) && + (idd->Area.area_idd == idd) ) + { + /* copy frame data, as much as possible */ + bytes = MIN(msg->buflen, (sizeof(idd->Area.area_buf) - idd->Area.area_len)); + + IddGetDataFromAdapter(idd, + (PUCHAR)idd->Area.area_buf + idd->Area.area_len, + (PUCHAR)msg->bufptr, + (USHORT)bytes); + +// NdisMoveMemory (idd->Area.area_buf + idd->Area.area_len, msg->bufptr, bytes); + + idd->Area.area_len += bytes; + + /* if last, complete */ + if ( msg->bufid == 3 ) + { + idd->Area.area_state = AREA_ST_DONE; + if ( idd->Area.area_handler ) + (*idd->Area.area_handler)(idd->Area.area_handler_arg, + idd->Area.area_id, + idd->Area.area_buf, + idd->Area.area_len); + } + } + } +} + +#pragma NDIS_INIT_FUNCTION(idd_add_def) + +/* add a definition to initialization definition database */ +INT +idd_add_def(IDD *idd, CHAR *name, CHAR *val) +{ + INT name_len = __strlen(name) + 1; + INT val_len = __strlen(val) + 1; + + D_LOG(D_ENTRY, ("idd_add_def: entry\n")); + + __strlwr(name); + + __strlwr(val); + + D_LOG(D_ENTRY, ("idd_add_def: name: [%s], val: [%s]\n", name, val)); + /* check for room */ + + if ( (idd->DefinitionTableLength + name_len + val_len) > IDD_DEF_SIZE ) + { + D_LOG(DIGIINIT, ("idd_add_def: no room in definition table!\n")); + return(IDD_E_NOROOM); + } + + /* enter into table */ + NdisMoveMemory(idd->DefinitionTable + idd->DefinitionTableLength, name, name_len); + idd->DefinitionTableLength += name_len; + + NdisMoveMemory(idd->DefinitionTable + idd->DefinitionTableLength, val, val_len); + idd->DefinitionTableLength += val_len; + + /* return success */ + return(IDD_E_SUCC); +} // end idd_add_def + +#pragma NDIS_INIT_FUNCTION(idd_get_nvram) + +/* get an nvram location */ +INT +idd_get_nvram(VOID *idd_1, USHORT addr, USHORT *val) +{ + IDD *idd = (IDD*)idd_1; + D_LOG(D_ENTRY, ("idd_get_nvram: entry, idd: 0x%lx, addr: 0x%x\n", idd, addr)); + + /* lock card */ + NdisAcquireSpinLock(&idd->lock); + + /* do the read */ + *val = idd->NVRamRead(idd, addr); + + /* release card & return */ + NdisReleaseSpinLock(&idd->lock); + D_LOG(D_EXIT, ("idd_get_nvram: exit, val: 0x%x\n", *val)); + return(IDD_E_SUCC); +} |