able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/net/irda/sigmatel/sys/ircommon.h

1114 lines
27 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/**************************************************************************************************************************
* IRCOMMON.H SigmaTel STIR4200 common USB/IR definitions
**************************************************************************************************************************
* (C) Unpublished Copyright of Sigmatel, Inc. All Rights Reserved.
*
*
* Created: 04/06/2000
* Version 0.9
* Edited: 04/24/2000
* Version 0.91
* Edited: 04/27/2000
* Version 0.92
* Edited: 05/03/2000
* Version 0.93
* Edited: 05/12/2000
* Version 0.94
* Edited: 05/19/2000
* Version 0.95
* Edited: 07/27/2000
* Version 1.01
* Edited: 09/16/2000
* Version 1.03
* Edited: 09/25/2000
* Version 1.10
* Edited: 11/09/2000
* Version 1.12
* Edited: 02/20/2001
* Version 1.15
*
**************************************************************************************************************************/
#ifndef _IRCOM_H
#define _IRCOM_H
#include "stir4200.h"
//
// This is for use by check-for-hang handler and is just a reasonable guess;
// Total # of USBD control errors, read aerrors and write errors;
// Used by check-for-hang handler to decide if we need a reset
//
#define IRUSB_100ns_PER_ms 10000
#define IRUSB_100ns_PER_us 10
#define IRUSB_ms_PER_SEC 1000
#define IRUSB_100ns_PER_SEC ( IRUSB_100ns_PER_ms * IRUSB_ms_PER_SEC )
#define MAX_QUERY_TIME_100ns ( 8 * IRUSB_100ns_PER_SEC ) //8 sec
#define MAX_SET_TIME_100ns MAX_QUERY_TIME_100ns
#define MAX_SEND_TIME_100ns ( 20 * IRUSB_100ns_PER_SEC ) //20 sec
#define MAX_TURNAROUND_usec 10000
#define DEFAULT_TURNAROUND_usec 1000
#define MIN(a,b) (((a) <= (b)) ? (a) : (b))
#define MAX(a,b) (((a) >= (b)) ? (a) : (b))
//
// A receive buffer is either FREE (not holding anything) FULL
// (holding undelivered data) or PENDING (holding data delivered
// asynchronously)
//
typedef enum
{
RCV_STATE_FREE,
RCV_STATE_FULL,
RCV_STATE_PENDING
} RCV_BUFFER_STATE, FIFO_BUFFER_STATE;
//
// Structure to keep track of receive packets and buffers to indicate
// receive data to the protocol.
//
typedef struct
{
PVOID pPacket;
UINT DataLen;
PUCHAR pDataBuf;
PVOID pThisDev;
ULONG fInRcvDpc;
RCV_BUFFER_STATE BufferState;
#if defined(DIAGS)
LIST_ENTRY ListEntry; // This will be used to do the diags queueing
#endif
#if defined(WORKAROUND_MISSING_C1)
BOOLEAN MissingC1Detected;
#endif
} RCV_BUFFER, *PRCV_BUFFER;
//
// Structure to read data from the FIFO
//
typedef struct
{
UINT DataLen;
PUCHAR pDataBuf;
PVOID pThisDev;
PVOID pIrp;
FIFO_BUFFER_STATE BufferState;
} FIFO_BUFFER, *PFIFO_BUFFER;
//
// All different sizes for data
//
#define IRDA_ADDRESS_FIELD_SIZE 1
#define IRDA_CONTROL_FIELD_SIZE 1
#define IRDA_A_C_TOTAL_SIZE ( IRDA_ADDRESS_FIELD_SIZE + IRDA_CONTROL_FIELD_SIZE )
#define USB_IRDA_TOTAL_NON_DATA_SIZE ( IRDA_ADDRESS_FIELD_SIZE + IRDA_CONTROL_FIELD_SIZE )
#define IRDA_MAX_DATAONLY_SIZE 2048
#define MAX_TOTAL_SIZE_WITH_ALL_HEADERS ( IRDA_MAX_DATAONLY_SIZE + USB_IRDA_TOTAL_NON_DATA_SIZE )
#define MAX_NUM_EXTRA_BOFS 48
#define MAX_POSSIBLE_IR_PACKET_SIZE_FOR_DATA(dataLen) ( \
(dataLen) * 2 + (MAX_NUM_EXTRA_BOFS + 1) * \
SLOW_IR_BOF_SIZE + IRDA_ADDRESS_FIELD_SIZE + IRDA_CONTROL_FIELD_SIZE + \
SLOW_IR_FCS_SIZE + SLOW_IR_EOF_SIZE) + sizeof(STIR4200_FRAME_HEADER)
//
// Note that the receive size needs to be incremented to account for
// the way the decoding can use one more byte
//
#define MAX_RCV_DATA_SIZE (MAX_TOTAL_SIZE_WITH_ALL_HEADERS + FAST_IR_FCS_SIZE + 1)
#define MAX_IRDA_DATA_SIZE MAX_POSSIBLE_IR_PACKET_SIZE_FOR_DATA(IRDA_MAX_DATAONLY_SIZE)
//
// Possible speeds
//
typedef enum _BAUD_RATE
{
//
// Slow IR
//
BAUDRATE_2400 = 0,
BAUDRATE_9600,
BAUDRATE_19200,
BAUDRATE_38400,
BAUDRATE_57600,
BAUDRATE_115200,
//
// Medium IR
//
#if !defined(DWORKAROUND_BROKEN_MIR)
BAUDRATE_576000,
BAUDRATE_1152000,
#endif
//
// Fast IR
//
BAUDRATE_4000000,
//
// must be last
//
NUM_BAUDRATES
} BAUD_RATE;
typedef enum _IR_MODE
{
IR_MODE_SIR = 0,
IR_MODE_MIR,
IR_MODE_FIR,
NUM_IR_MODES
} IR_MODE;
//
// Speeds
//
#define SPEED_2400 2400
#define SPEED_9600 9600
#define SPEED_19200 19200
#define SPEED_38400 38400
#define SPEED_57600 57600
#define SPEED_115200 115200
#define SPEED_576000 576000
#define SPEED_1152000 1152000
#define SPEED_4000000 4000000
#define DEFAULT_BAUD_RATE SPEED_9600
#define MAX_SIR_SPEED SPEED_115200
#define MAX_MIR_SPEED SPEED_1152000
//
// Sizes of IrLAP frame fields:
// Beginning Of Frame (BOF)
// End Of Frame (EOF)
// Address
// Control
//
#define SLOW_IR_BOF_TYPE UCHAR
#define SLOW_IR_BOF_SIZE sizeof(SLOW_IR_BOF_TYPE)
#define SLOW_IR_EOF_TYPE UCHAR
#define SLOW_IR_EOF_SIZE sizeof(SLOW_IR_EOF_TYPE)
#define SLOW_IR_FCS_TYPE USHORT
#define SLOW_IR_FCS_SIZE sizeof(SLOW_IR_FCS_TYPE)
#define SLOW_IR_BOF 0xC0
#define SLOW_IR_EOF 0xC1
#define SLOW_IR_ESC 0x7D
#define SLOW_IR_ESC_COMP 0x20
#define SLOW_IR_EXTRA_BOF_TYPE UCHAR
#define SLOW_IR_EXTRA_BOF_SIZE sizeof(SLOW_IR_EXTRA_BOF_TYPE)
#define SLOW_IR_EXTRA_BOF 0xC0
#define MEDIUM_IR_BOF 0x7E
#define MEDIUM_IR_EOF 0x7E
#define MEDIUM_IR_FCS_TYPE USHORT
#define MEDIUM_IR_FCS_SIZE sizeof(MEDIUM_IR_FCS_TYPE)
#define FAST_IR_FCS_TYPE ULONG
#define FAST_IR_FCS_SIZE sizeof(FAST_IR_FCS_TYPE)
#define FAST_IR_EOF_TYPE ULONG
#define FAST_IR_EOF_SIZE sizeof(FAST_IR_EOF_TYPE)
//
// Definition for speed masks
//
#define NDIS_IRDA_SPEED_MASK_2400 0x001 // SLOW IR ...
#define NDIS_IRDA_SPEED_MASK_9600 0x003
#define NDIS_IRDA_SPEED_MASK_19200 0x007
#define NDIS_IRDA_SPEED_MASK_38400 0x00f
#define NDIS_IRDA_SPEED_MASK_57600 0x01f
#define NDIS_IRDA_SPEED_MASK_115200 0x03f
#define NDIS_IRDA_SPEED_MASK_576K 0x07f // MEDIUM IR ...
#define NDIS_IRDA_SPEED_MASK_1152K 0x0ff
#define NDIS_IRDA_SPEED_MASK_4M 0x1ff // FAST IR
#define GOOD_FCS ((USHORT) ~0xf0b8)
#define FIR_GOOD_FCS ((ULONG) ~0xdebb20e3)
typedef struct
{
BAUD_RATE TableIndex;
UINT BitsPerSec;
IR_MODE IrMode;
UINT NdisCode; // bitmask element as used by ndis and in class-specific descriptor
UCHAR Stir4200Divisor;
} BAUDRATE_INFO;
//
// Struct to hold the IR USB dongle's USB Class-Specific Descriptor as per
// "Universal Serial Bus IrDA Bridge Device Definition" doc, section 7.2
// This is the struct returned by USBD as the result of a request with an urb
// of type _URB_CONTROL_VENDOR_OR_CLASS_REQUEST, function URB_FUNCTION_CLASS_DEVICE
//
// Enable 1-byte alignment in the below struct
#pragma pack (push,1)
typedef struct _IRUSB_CLASS_SPECIFIC_DESCRIPTOR
{
BOOLEAN ClassConfigured;
UCHAR bmDataSize; // max bytes allowed in any frame as per IrLAP spec, where:
#define BM_DATA_SIZE_2048 (1 << 5)
#define BM_DATA_SIZE_1024 (1 << 4)
#define BM_DATA_SIZE_512 (1 << 3)
#define BM_DATA_SIZE_256 (1 << 2)
#define BM_DATA_SIZE_128 (1 << 1)
#define BM_DATA_SIZE_64 (1 << 0)
UCHAR bmWindowSize; // max un-acked frames that can be received
// before an ack is sent, where:
#define BM_WINDOW_SIZE_7 (1 << 6)
#define BM_WINDOW_SIZE_6 (1 << 5)
#define BM_WINDOW_SIZE_5 (1 << 4)
#define BM_WINDOW_SIZE_4 (1 << 3)
#define BM_WINDOW_SIZE_3 (1 << 2)
#define BM_WINDOW_SIZE_2 (1 << 1)
#define BM_WINDOW_SIZE_1 (1 << 0)
UCHAR bmMinTurnaroundTime; // min millisecs required for recovery between
// end of last xmission and can receive again, where:
#define BM_TURNAROUND_TIME_0ms (1 << 7) // 0 ms
#define BM_TURNAROUND_TIME_0p01ms (1 << 6) // 0.01 ms
#define BM_TURNAROUND_TIME_0p05ms (1 << 5) // 0.05 ms
#define BM_TURNAROUND_TIME_0p1ms (1 << 4) // 0.1 ms
#define BM_TURNAROUND_TIME_0p5ms (1 << 3) // 0.5 ms
#define BM_TURNAROUND_TIME_1ms (1 << 2) // 1 ms
#define BM_TURNAROUND_TIME_5ms (1 << 1) // 5 ms
#define BM_TURNAROUND_TIME_10ms (1 << 0) // 10 ms
USHORT wBaudRate;
//
// ir speed masks as used both by NDIS and as formatted in USB class-specfic descriptor
//
#define NDIS_IRDA_SPEED_2400 (1 << 0) // SLOW IR ...
#define NDIS_IRDA_SPEED_9600 (1 << 1)
#define NDIS_IRDA_SPEED_19200 (1 << 2)
#define NDIS_IRDA_SPEED_38400 (1 << 3)
#define NDIS_IRDA_SPEED_57600 (1 << 4)
#define NDIS_IRDA_SPEED_115200 (1 << 5)
#define NDIS_IRDA_SPEED_576K (1 << 6) // MEDIUM IR ...
#define NDIS_IRDA_SPEED_1152K (1 << 7)
#define NDIS_IRDA_SPEED_4M (1 << 8) // FAST IR
UCHAR bmExtraBofs; // #BOFS required at 115200; 0 if slow speeds <=115200 not supported
#define BM_EXTRA_BOFS_0 (1 << 7)
#define BM_EXTRA_BOFS_1 (1 << 6)
#define BM_EXTRA_BOFS_2 (1 << 5)
#define BM_EXTRA_BOFS_3 (1 << 4)
#define BM_EXTRA_BOFS_6 (1 << 3)
#define BM_EXTRA_BOFS_12 (1 << 2)
#define BM_EXTRA_BOFS_24 (1 << 1)
#define BM_EXTRA_BOFS_48 (1 << 0)
} IRUSB_CLASS_SPECIFIC_DESCRIPTOR, *PIRUSB_CLASS_SPECIFIC_DESCRIPTOR;
#pragma pack (pop) //disable 1-byte alignment
typedef struct _DONGLE_CAPABILITIES
{
//
// Time (in microseconds) that must transpire between
// a transmit and the next receive.
//
LONG turnAroundTime_usec; // gotten from class-specific descriptor
//
// Max un-acked frames that can be received
// before an ack is sent
//
UINT windowSize; // gotten from class-specific descriptor
//
// #BOFS required at 115200; 0 if slow speeds <=115200 are not supported
//
UINT extraBOFS; // gotten from class-specific descriptor
//
// max bytes allowed in any frame as per IrLAP spec
//
UINT dataSize; // gotten from class-specific descriptor
} DONGLE_CAPABILITIES, *PDONGLE_CAPABILITIES;
//
// Enum of context types for SendPacket
//
typedef enum _CONTEXT_TYPE
{
CONTEXT_NDIS_PACKET,
CONTEXT_SET_SPEED,
CONTEXT_READ_WRITE_REGISTER,
CONTEXT_DIAGS_ENABLE,
CONTEXT_DIAGS_DISABLE,
CONTEXT_DIAGS_READ_REGISTERS,
CONTEXT_DIAGS_WRITE_REGISTER,
CONTEXT_DIAGS_BULK_OUT,
CONTEXT_DIAGS_BULK_IN,
CONTEXT_DIAGS_SEND
} CONTEXT_TYPE;
typedef VOID (*WORK_PROC)(struct _IR_WORK_ITEM *);
typedef struct _IR_WORK_ITEM
{
PVOID pIrDevice;
WORK_PROC Callback;
PUCHAR pInfoBuf;
ULONG InfoBufLen;
ULONG fInUse; // declared as ulong for use with interlockedexchange
} IR_WORK_ITEM, *PIR_WORK_ITEM;
//
// Transceiver type definition
//
typedef enum _TRANSCEIVER_TYPE
{
TRANSCEIVER_4012 = 0,
TRANSCEIVER_4000,
TRANSCEIVER_VISHAY,
TRANSCEIVER_INFINEON
} TRANSCEIVER_TYPE;
//
// Chip revision definition
//
typedef enum _CHIP_REVISION
{
CHIP_REVISION_6 = 5,
CHIP_REVISION_7,
CHIP_REVISION_8
} CHIP_REVISION;
typedef struct _IR_DEVICE
{
//
// Keep track of various device objects.
//
PDEVICE_OBJECT pUsbDevObj; //'Next Device Object'
PDEVICE_OBJECT pPhysDevObj; // Physical Device Object
//
// This is the handle that the NDIS wrapper associates with a connection.
// (The handle that the miniport driver associates with the connection
// is just an index into the devStates array).
//
HANDLE hNdisAdapter;
//
// The dongle interface allows us to check the tranceiver type once
// and then set up the interface to allow us to init, set speed,
// and deinit the dongle.
//
// We also want the dongle capabilities.
//
DONGLE_CAPABILITIES dongleCaps;
//
// Type of transceiver installed
//
TRANSCEIVER_TYPE TransceiverType;
//
// Revision of the installed 4200
//
CHIP_REVISION ChipRevision;
//
// Current speed setting, in bits/sec.
// Note: This is updated when we ACTUALLY change the speed,
// not when we get the request to change speed via
// irusbSetInformation.
//
//
// When speed is changed, we have to clear the send queue before
// setting the new speed on the hardware.
// These vars let us remember to do it.
//
UINT currentSpeed;
//
// Current link speed information. This also will maintain the
// chosen speed if the protocol requests a speed change.
//
BAUDRATE_INFO *linkSpeedInfo;
//
// Maintain statistical debug info.
//
ULONG packetsReceived;
ULONG packetsReceivedDropped;
ULONG packetsReceivedOverflow;
ULONG packetsReceivedChecksum;
ULONG packetsReceivedRunt;
ULONG packetsReceivedNoBuffer;
ULONG packetsSent;
ULONG packetsSentDropped;
ULONG packetsSentRejected;
ULONG packetsSentInvalid;
#if DBG
ULONG packetsHeldByProtocol;
ULONG MaxPacketsHeldByProtocol;
ULONG TotalBytesReceived;
ULONG TotalBytesSent;
ULONG NumYesQueryMediaBusyOids;
ULONG NumNoQueryMediaBusyOids;
ULONG NumSetMediaBusyOids;
ULONG NumMediaBusyIndications;
ULONG NumPacketsSentRequiringTurnaroundTime;
ULONG NumPacketsSentNotRequiringTurnaroundTime;
#endif
//
// used by check hang handler to track Query, Set, and Send times
//
LARGE_INTEGER LastQueryTime;
LARGE_INTEGER LastSetTime;
BOOLEAN fSetpending;
BOOLEAN fQuerypending;
//
// Set when device has been started; use for safe cleanup after failed initialization
//
BOOLEAN fDeviceStarted;
//
// Indicates that we have received an OID_GEN_CURRENT_PACKET_FILTER
// indication from the protocol. We can deliver received packets to the
// protocol.
//
BOOLEAN fGotFilterIndication;
//
// NDIS calls most of the MiniportXxx function with IRQL DISPATCH_LEVEL.
// There are a number of instances where the ir device must send
// requests to the device which may be synchronous and
// we can't block in DISPATCH_LEVEL. Therefore, we set up a thread to deal
// with request which require PASSIVE_LEVEL. An event is used to signal
// the thread that work is required.
//
HANDLE hPassiveThread;
BOOLEAN fKillPassiveLevelThread;
KEVENT EventPassiveThread;
/*
According to W2000 ddk doc:
The IrDA protocol driver sets this OID to zero to request the miniport to
start monitoring for a media busy condition. The IrDA protocol
can then query this OID to determine whether the media is busy.
If the media is not busy, the miniport returns a zero for this
OID when queried. If the media is busy,that is, if the miniport
has detected some traffic since the IrDA protocol driver last
set OID_IRDA_MEDIA_BUSY to zero the miniport returns a non-zero
value for this OID when queried. On detecting the media busy
condition. the miniport must also call NdisMIndicateStatus to
indicate NDIS_STATUS_MEDIA_BUSY. When the media is busy,
the IrDA protocol driver will not send packets to the miniport
for transmission. After the miniport has detected a busy state,
it does not have to monitor for a media busy condition until
the IrDA protocol driver again sets OID_IRDA_MEDIA_BUSY to zero.
According to USB IrDA Bridge Device Definition Doc sec 5.4.1.2:
The bmStatus field indicators shall be set by the Device as follows:
Media_Busy
<EFBFBD> Media_Busy shall indicate zero (0) if the Device:
. has not received a Check Media Busy class-specific request
. has detected no traffic on the infrared media since receiving a Check Media Busy
. class-specific request
. Has returned a header with Media_Busy set to one (1) since receiving a Check
Media Busy class-specific request.
<EFBFBD> Media_Busy shall indicate one (1) if the Device has detected traffic on the infrared
media since receiving a Check Media Busy class-specific request. Note that
Media_Busy shall indicate one (1) in exactly one header following receipt of each
Check Media Busy class-specific request.
According to USB IrDA Bridge Device Definition Doc sec 6.2.2:
Check Media Busy
This class-specific request instructs the Device to look for a media busy condition. If infrared
traffic of any kind is detected by this Device, the Device shall set the Media_Busy field in the
bmStatus field in the next Data-In packet header sent to the host. In the case where a Check
Media Busy command has been received, a media busy condition detected, and no IrLAP frame
traffic is ready to transmit to the host, the Device shall set the Media_Busy field and send it in a
Data-In packet with no IrLAP frame following the header.
bmRequestType bRequest wValue wIndex wLength Data
00100001B 3 Zero Interface Zero [None]
*/
ULONG fMediaBusy; // declare as ULONGS for use with InterlockedExchange
ULONG fIndicatedMediaBusy;
//
// The variable fProcessing is used to indicate that the ir device
// object has an active polling thread,
//
// Under normal circumstances fReceiving should always be TRUE.
// However sometimes the processing has to be stopped
// and this variable is used to synchronize
//
ULONG fProcessing;
//
// To be set to true when really receiving packets
//
ULONG fCurrentlyReceiving;
//
// The variables fPendingHalt and fPendingReset allow the send and receive
// completion routines to complete the current pending irp and
// then cleanup and stop sending irps to the USB driver.
//
BOOLEAN fPendingHalt;
BOOLEAN fPendingReset;
ULONG fPendingReadClearStall;
ULONG fPendingWriteClearStall;
//
// This is required when the part gets into a complete USB hang and a reset is required
//
ULONG fPendingClearTotalStall;
//
// We keep an array of receive buffers so that we don't continually
// need to allocate buffers to indicate packets to the protocol.
// Since the protocol can retain ownership of up to eight packets
// and we can be receiving up to WindowSize ( 7 ) packets while the protocol has
// ownership of eight packets, we will allocate 16 packets for
// receiving.
//
#define NUM_RCV_BUFS 16
RCV_BUFFER rcvBufs[NUM_RCV_BUFS];
PRCV_BUFFER pCurrentRecBuf;
FIFO_BUFFER PreReadBuffer;
//
// Can have max of NUM_RCV_BUFS packets pending + one set and one query
//
#define NUM_WORK_ITEMS (NUM_RCV_BUFS+3)
IR_WORK_ITEM WorkItems[NUM_WORK_ITEMS];
//
// Since we can have multiple write irps pending with the USB driver,
// we track the irp contexts for each one so we have all the info we need at each
// invokation of the USB write completion routine. See the IRUSB_CONTEXT definition below
// There are 128 contexts for sending, one for read/write operations, one for setting the speed
// and one for diagnostic operations
//
#define NUM_SEND_CONTEXTS 131
PVOID pSendContexts;
//
// Handles to the NDIS packet pool and NDIS buffer pool
// for allocating the receive buffers.
//
HANDLE hPacketPool;
HANDLE hBufferPool;
BOOLEAN BufferPoolAllocated;
KEVENT EventSyncUrb;
KEVENT EventAsyncUrb;
NTSTATUS StatusControl;
NTSTATUS StatusReadWrite;
NTSTATUS StatusSendReceive;
//
// track pending IRPS; this should be zero at halt time
//
UINT PendingIrpCount;
ULONG NumReads;
ULONG NumWrites;
ULONG NumReadWrites;
//
// various USB errors
//
ULONG NumDataErrors;
ULONG NumReadWriteErrors;
HANDLE BulkInPipeHandle;
HANDLE BulkOutPipeHandle;
HANDLE hPollingThread;
BOOLEAN fKillPollingThread;
//
// The IR USB dongle's USB Class-Specific Descriptor as per
// "Universal Serial Bus IrDA Bridge Device Definition" doc, section 7.2
// This is the struct returned by USBD as the result of a request with an urb
// of type _URB_CONTROL_VENDOR_OR_CLASS_REQUEST, function URB_FUNCTION_CLASS_DEVICE.
// Note this struct is in-line, not a pointer
//
IRUSB_CLASS_SPECIFIC_DESCRIPTOR ClassDesc;
UINT IdVendor; // USB vendor Id read from dongle
//
// We don't define it here because we need to isolate USB stuff so we
// can build things referencing NDIS with the BINARY_COMPATIBLE flag for win9x
//
PUCHAR pUsbInfo;
//
// Optional registry entry for debugging; limit baud rate.
// The mask is set up as per the USB Class-Specific descriptor 'wBaudRate'
// This is 'and'ed with value from Class descriptor to possibly limit baud rate;
// It defaults to 0xffff
//
UINT BaudRateMask;
//
// Necessary to read the registry fields
//
NDIS_HANDLE WrapperConfigurationContext;
//
// IR Tranceiver Model
//
STIR4200_TRANCEIVER StIrTranceiver;
//
// Send buffers (works only if sending is serialied)
//
PUCHAR pBuffer;
UINT BufLen;
PUCHAR pStagingBuffer;
//
// Send FIFO count
//
ULONG SendFifoCount;
//
// Receive adaptive delay
//
ULONG ReceiveAdaptiveDelay;
ULONG ReceiveAdaptiveDelayBoost;
//
// Send URB (works only if sending is serialied)
//
PURB pUrb;
UINT UrbLen;
//
// Receive buffer and positions
//
UCHAR pRawBuf[STIR4200_FIFO_SIZE];
ULONG rawCleanupBytesRead;
PORT_RCV_STATE rcvState;
ULONG readBufPos;
BOOLEAN fReadHoldingReg;
ULONG PreFifoCount;
//
// Send lists and lock
//
LIST_ENTRY SendAvailableQueue;
LIST_ENTRY SendBuiltQueue;
LIST_ENTRY SendPendingQueue;
ULONG SendAvailableCount;
ULONG SendBuiltCount;
ULONG SendPendingCount;
KSPIN_LOCK SendLock;
//
// Read and write register list, shares the other send queues
//
LIST_ENTRY ReadWritePendingQueue;
ULONG ReadWritePendingCount;
//
// Diagnostics
//
#if defined(DIAGS)
ULONG DiagsActive;
ULONG DiagsPendingActivation;
PVOID pIOCTL;
NTSTATUS IOCTLStatus;
NDIS_HANDLE NdisDeviceHandle;
KEVENT EventDiags;
LIST_ENTRY DiagsReceiveQueue;
KSPIN_LOCK DiagsReceiveLock;
#endif
//
// Logging
//
#if defined(RECEIVE_LOGGING)
HANDLE ReceiveFileHandle;
__int64 ReceiveFilePosition;
#endif
#if defined(RECEIVE_ERROR_LOGGING)
HANDLE ReceiveErrorFileHandle;
__int64 ReceiveErrorFilePosition;
#endif
#if defined(SEND_LOGGING)
HANDLE SendFileHandle;
__int64 SendFilePosition;
#endif
#if !defined(WORKAROUND_BROKEN_MIR)
//
// Mir in software
//
UCHAR pRawUnstuffedBuf[STIR4200_FIFO_SIZE];
UCHAR MirIncompleteByte;
ULONG MirIncompleteBitCount;
ULONG MirOneBitCount;
ULONG MirFlagCount;
#endif
//
// Dummy send fix
//
BOOLEAN GearedDown;
//
// temporary Fix!
//
//ULONG SirDpll;
//ULONG FirDpll;
//ULONG SirSensitivity;
//ULONG FirSensitivity;
} IR_DEVICE, *PIR_DEVICE;
//
// We use a pointer to the IR_DEVICE structure as the miniport's device context.
//
#define CONTEXT_TO_DEV(__deviceContext) ((PIR_DEVICE)(__deviceContext))
#define DEV_TO_CONTEXT(__irdev) ((HANDLE)(__irdev))
#define IRUSB_TAG 'RITS'
VOID
MyNdisMSetInformationComplete(
IN PIR_DEVICE pThisDev,
IN NDIS_STATUS Status
);
VOID
MyNdisMQueryInformationComplete(
IN PIR_DEVICE pThisDev,
IN NDIS_STATUS Status
);
USHORT
ComputeFCS16(
IN PUCHAR pData,
UINT DataLen
);
ULONG
ComputeFCS32(
IN PUCHAR pData,
ULONG DataLen
);
BOOLEAN
NdisToFirPacket(
IN PIR_DEVICE pIrDev,
IN PNDIS_PACKET pPacket,
OUT PUCHAR pIrPacketBuf,
ULONG IrPacketBufLen,
IN PUCHAR pContigPacketBuf,
OUT PULONG pIrPacketLen
);
BOOLEAN
NdisToMirPacket(
IN PIR_DEVICE pIrDev,
IN PNDIS_PACKET pPacket,
OUT PUCHAR pIrPacketBuf,
ULONG IrPacketBufLen,
IN PUCHAR pContigPacketBuf,
OUT PULONG pIrPacketLen
);
BOOLEAN
NdisToSirPacket(
IN PIR_DEVICE pIrDev,
IN PNDIS_PACKET pPacket,
OUT PUCHAR pIrPacketBuf,
ULONG IrPacketBufLen,
IN PUCHAR pContigPacketBuf,
OUT PULONG pIrPacketLen
);
BOOLEAN
ReceiveFirStepFSM(
IN OUT PIR_DEVICE pIrDev,
OUT PULONG pBytesProcessed
);
BOOLEAN
ReceiveMirStepFSM(
IN OUT PIR_DEVICE pIrDev,
OUT PULONG pBytesProcessed
);
#if !defined(WORKAROUND_BROKEN_MIR)
BOOLEAN
ReceiveMirUnstuff(
IN OUT PIR_DEVICE pIrDev,
IN PUCHAR pInputBuffer,
ULONG InputBufferSize,
OUT PUCHAR pOutputBuffer,
OUT PULONG pOutputBufferSize
);
#endif
BOOLEAN
ReceiveSirStepFSM(
IN OUT PIR_DEVICE pIrDev,
OUT PULONG pBytesProcessed
);
VOID
ReceiveProcessFifoData(
IN OUT PIR_DEVICE pThisDev
);
VOID
ReceiveResetPointers(
IN OUT PIR_DEVICE pThisDev
);
NTSTATUS
ReceivePreprocessFifo(
IN OUT PIR_DEVICE pThisDev,
OUT PULONG pFifoCount
);
NTSTATUS
ReceiveGetFifoData(
IN OUT PIR_DEVICE pThisDev,
OUT PUCHAR pData,
OUT PULONG pBytesRead,
ULONG BytesToRead
);
VOID
ReceiveProcessReturnPacket(
OUT PIR_DEVICE pThisDev,
OUT PRCV_BUFFER pReceiveBuffer
);
NTSTATUS
ReceivePacketRead(
IN PIR_DEVICE pThisDev,
OUT PFIFO_BUFFER pRecBuf
);
NTSTATUS
ReceiveCompletePacketRead(
IN PDEVICE_OBJECT pUsbDevObj,
IN PIRP pIrp,
IN PVOID Context
);
VOID
IndicateMediaBusy(
IN PIR_DEVICE pThisDev
);
VOID
IrUsb_IncIoCount(
IN OUT PIR_DEVICE pThisDev
);
VOID
IrUsb_DecIoCount(
IN OUT PIR_DEVICE pThisDev
);
NTSTATUS
IrUsb_GetDongleCaps(
IN OUT PIR_DEVICE pThisDev
);
VOID
IrUsb_SetDongleCaps(
IN OUT PIR_DEVICE pThisDev
);
VOID
MyMemFree(
IN PVOID pMem,
IN UINT size
);
PVOID
MyMemAlloc(
UINT size
);
BOOLEAN
AllocUsbInfo(
IN OUT PIR_DEVICE pThisDev
);
VOID
FreeUsbInfo(
IN OUT PIR_DEVICE pThisDev
);
VOID
PollingThread(
IN OUT PVOID Context
);
extern BAUDRATE_INFO supportedBaudRateTable[NUM_BAUDRATES];
VOID
ReceiveDeliverBuffer(
IN OUT PIR_DEVICE pThisDev,
IN PRCV_BUFFER pRecBuf
);
NTSTATUS
InitializeProcessing(
IN OUT PIR_DEVICE pThisDev,
IN BOOLEAN InitPassiveThread
);
NTSTATUS
IrUsb_ResetPipe (
IN PIR_DEVICE pThisDev,
IN HANDLE Pipe
);
BOOLEAN
IrUsb_InitSendStructures(
IN OUT PIR_DEVICE pThisDev
);
VOID
IrUsb_FreeSendStructures(
IN OUT PIR_DEVICE pThisDev
);
NDIS_STATUS
SendPacketPreprocess(
IN OUT PIR_DEVICE pThisDev,
IN PVOID pPacketToSend
);
NDIS_STATUS
SendPreprocessedPacketSend(
IN OUT PIR_DEVICE pThisDev,
IN PVOID pContext
);
NTSTATUS
SendWaitCompletion(
IN OUT PIR_DEVICE pThisDev
);
NTSTATUS
SendCheckForOverflow(
IN OUT PIR_DEVICE pThisDev
);
NTSTATUS
SendCompletePacketSend(
IN PDEVICE_OBJECT pUsbDevObj,
IN PIRP pIrp,
IN PVOID Context
);
PRCV_BUFFER
ReceiveGetBuf(
PIR_DEVICE pThisDev,
OUT PUINT pIndex,
IN RCV_BUFFER_STATE BufferState
);
VOID
PassiveLevelThread(
IN PVOID Context
);
BOOLEAN
ScheduleWorkItem(
IN OUT PIR_DEVICE pThisDev,
WORK_PROC Callback,
IN PVOID pInfoBuf,
ULONG InfoBufLen
);
VOID
FreeWorkItem(
IN OUT PIR_WORK_ITEM pItem
);
VOID
IrUsb_PrepareSetSpeed(
IN OUT PIR_DEVICE pThisDev
);
VOID
ResetPipeCallback (
IN PIR_WORK_ITEM pWorkItem
);
PVOID
AllocXferUrb (
VOID
);
VOID
FreeXferUrb(
IN OUT PVOID pUrb
);
BOOLEAN
IrUsb_CancelPendingReadIo(
IN OUT PIR_DEVICE pThisDev,
BOOLEAN fWaitCancelComplete
);
BOOLEAN
IrUsb_CancelPendingWriteIo(
IN OUT PIR_DEVICE pThisDev
);
BOOLEAN
IrUsb_CancelPendingReadWriteIo(
IN OUT PIR_DEVICE pThisDev
);
#endif // _IRCOM_H
Reference in a new issue Copy permalink