WebSVN – f9daq – Blame – //drivers/wiener_pcicc32/SOURCE/pcicc32_io.c

Rev	Author	Line No.	Line
23	f9daq	1	//-------------------------------------------------------------------------
		2	// WINNT driver for PCICC32 interface from ARW Elektronik, Germany ---------
		3	// the ioctl functions
		4	//
		5	// (c) 1999-2002 ARW Elektronik
		6	//
		7	// this source code is published under GPL (Open Source). You can use, redistrubute and
		8	// modify it unless this header is not modified or deleted. No warranty is given that
		9	// this software will work like expected.
		10	// This product is not authorized for use as critical component in life support systems
		11	// wihout the express written approval of ARW Elektronik Germany.
		12	//
		13	// Please announce changes and hints to ARW Elektronik
		14	//
		15	// what who when
		16	// started AR 03.07.1999
		17	// first release 1.0 AR 17.10.1999
		18	// added access to PLX LC-Register AR 30.03.2001
		19	// changed making procedure (only VCC > 6.0) AR 30.05.2002
		20	// multiple interrupt enable allowed AR 01.06.2002
		21	// added KeSynchronizeExecution for interrupt sync AR 16.06.2002
		22	// extended ioctl_irq_status_kernel AR 18.06.2002
		23	//
		24
		25	//-------------------------------------------------------------------------
		26	// INCLUDES
		27	//
		28	#include <ntddk.h>
		29	#include <devioctl.h>
		30	#include <pcicc32_drv.h>
		31	#include <pcicc32.h>
		32	#include <pcicc32_v.h>
		33	#include <pcicc32_io.h>
		34	#include <pcicc32_local.h>
		35	#include <pcicc32_i.h>
		36
		37	//------------------------------------------------------------------------
		38	// DEFINES
		39	//
		40
		41	// buffers usage must match the corresponding ioctl code!
		42	#define SET_BUFFERS_METHOD_OUT_DIRECT \
		43	{\
		44	InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
		45	OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
		46	pInputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
		47	pOutputBuffer = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));\
		48	}
		49
		50	#define SET_BUFFERS_METHOD_IN_DIRECT \
		51	{\
		52	InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
		53	OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
		54	pInputBuffer = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));\
		55	pOutputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
		56	}
		57
		58	#define SET_BUFFERS_METHOD_BUFFERED \
		59	{\
		60	InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
		61	OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
		62	pInputBuffer = pOutputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
		63	}
		64
		65	#define COMPLETE_REQUEST \
		66	{\
		67	if (Status != STATUS_PENDING)\
		68	{\
		69	Irp->IoStatus.Status = Status; \
		70	Irp->IoStatus.Information = irp_info; \
		71	IoCompleteRequest(Irp,IO_NO_INCREMENT); \
		72	}\
		73	}
		74
		75	// compatibilty issues to WIN95 driver calls
		76	#ifndef WORD
		77	#define WORD USHORT
		78	#endif
		79
		80	#ifndef DWORD
		81	#define DWORD ULONG
		82	#endif
		83
		84	#ifndef BYTE
		85	#define BYTE UCHAR
		86	#endif
		87
		88	#ifndef BOOL
		89	#define BOOL BOOLEAN
		90	#endif
		91
		92
		93	//-------------------------------------------------------------------------
		94	// TYPEDEFS
		95	//
		96	typedef struct
		97	{
		98	FILE_OBJ *file_obj;
		99	PCIADA *pciada;
		100	PCICC32_IRQ_RESPONSE *pIrqStatus;
		101	PIRP *Irp;
		102	ULONG *irp_info;
		103	NTSTATUS *Status;
		104	} IOCTL_IRQ_STATUS_CONTEXT;
		105
		106	//--------------------------------------------------------------------------
		107	// LOCAL FUNCTIONS
		108	//
		109
		110	//--------------------------------------------------------------------------
		111	// fast read or write functions - portable -
		112	static void readWord(void to, void from)
		113	{
		114	*(PUSHORT)to = READ_REGISTER_USHORT((PUSHORT)from);
		115	}
		116
		117	static void readLong(void to, void from)
		118	{
		119	*(PULONG)to = READ_REGISTER_ULONG((PULONG)from);
		120	}
		121
		122	static void writeWord(void to, void from)
		123	{
		124	WRITE_REGISTER_USHORT((PUSHORT)to, *(PUSHORT)from);
		125	}
		126
		127	static void writeLong(void to, void from)
		128	{
		129	WRITE_REGISTER_ULONG((PULONG)to, *(PULONG)from);
		130	}
		131
		132	//------------------------------------------------------------------------
		133	// init the interface with build in and user supplied constants
		134	static BOOLEAN InitInterface(PVOID pvLcr, PVOID pvIfr)
		135	{
		136	return TRUE;
		137	}
		138
		139	// deinit the interface with user supplied and build in constants
		140	static BOOLEAN DeInitInterface(PVOID pvLcr, PVOID pvIfr)
		141	{
		142	return TRUE;
		143	}
		144
		145	//------------------------------------------------------------------------
		146	// the default cancel routine for an queued Irp
		147	//
		148	void CancelRequest(PDEVICE_OBJECT device_Obj, PIRP Irp)
		149	{
		150	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		151	DEVICE_EXT pDevExt = (DEVICE_EXT )(device_Obj->DeviceExtension);
		152	PCIADA *pciada = pDevExt->cc32[file_obj->uwAssociatedCC32];
		153
		154	if (pciada->pBlockingIrp == (PIRP *)NULL)
		155	{
		156	IoReleaseCancelSpinLock(Irp->CancelIrql);
		157	KdPrint(("Nothing to do: CancelRequest(0x%08x)\n", Irp));
		158	return;
		159	}
		160	else
		161	{
		162	// release control of interrupt
		163	if (pciada->pIrqControlFile == file_obj)
		164	{
		165	pciada->pIrqControlFile = (FILE_OBJ *)NULL;
		166	globalInterruptDisable(pciada);
		167	}
		168
		169	// cancel any blocking Irp origin from this file
		170	if (file_obj->blockingIrp != (PIRP)NULL)
		171	file_obj->blockingIrp = (PIRP)NULL;
		172
		173	if (pciada->pBlockingIrp == &file_obj->blockingIrp)
		174	pciada->pBlockingIrp = (PIRP *)NULL;
		175
		176	IoReleaseCancelSpinLock(Irp->CancelIrql);
		177
		178	KdPrint(("Done: CancelRequest(0x%08x)\n", Irp));
		179
		180	Irp->IoStatus.Status = STATUS_CANCELLED;
		181	Irp->IoStatus.Information = 0;
		182
		183	IoCompleteRequest(Irp, IO_NO_INCREMENT);
		184	}
		185	}
		186
		187	//------------------------------------------------------------------------
		188	// the custom deffered routine to finish blocking io on irq_block
		189	void fMyDefferedRoutine(PKDPC Dpc, PVOID pvDevice_object, PVOID pvPciada, PVOID pdwIrqStatus)
		190	{
		191	NTSTATUS Status = STATUS_SUCCESS;
		192	ULONG irp_info = sizeof(PCICC32_IRQ_RESPONSE);
		193	PIRP Irp = (PIRP)NULL;
		194	PCIADA pciada = (PCIADA )pvPciada;
		195	KIRQL oldIrqlCancel;
		196
		197	KdPrint(("fMyDefferedRoutine(0x%08x)\n", pciada->dwIrqStatus));
		198
		199	// beware off damage due to intercept at cancel of thread
		200	IoAcquireCancelSpinLock(&oldIrqlCancel);
		201
		202	// get my associated packet
		203	if (pciada->pBlockingIrp != (PIRP *)NULL)
		204	{
		205	Irp = *pciada->pBlockingIrp;
		206
		207	if (Irp != (PIRP)NULL) // then a blcoking Irp is waiting
		208	{
		209	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		210	PCICC32_IRQ_RESPONSE pIrqStatus = (PCICC32_IRQ_RESPONSE )(Irp->AssociatedIrp.SystemBuffer);
		211
		212	// fill the response structure
		213	pIrqStatus->dwInterruptFlags = pciada->dwIrqStatus;
		214	pciada->dwIrqStatus = 0; // to prevent a following direct return
		215	pIrqStatus->dwInterface = file_obj->uwAssociatedCC32;
		216
		217	// release the cancel routine from this Irp
		218	IoSetCancelRoutine(Irp, NULL);
		219
		220	COMPLETE_REQUEST;
		221
		222	file_obj->blockingIrp = (PIRP)NULL;
		223	}
		224
		225	pciada->pBlockingIrp = (PIRP *)NULL;
		226	}
		227
		228	// release the spin locks
		229	IoReleaseCancelSpinLock(oldIrqlCancel);
		230	}
		231
		232	//------------------------------------------------------------------------
		233	// if the interrupt is disabled for a blocking path, cancel the block
		234	static void ReleaseBlockingIrp(PDEVICE_OBJECT device_Obj, PCIADA *pciada, PFILE_OBJ pFile_obj)
		235	{
		236	NTSTATUS Status = STATUS_CANCELLED;
		237	ULONG irp_info = sizeof(PCICC32_IRQ_RESPONSE);
		238	PIRP Irp = (PIRP)NULL;
		239	KIRQL oldIrqlCancel;
		240
		241	KdPrint(("ReleaseBlockingIrp()\n"));
		242
		243	// beware off damage due to intercept with cancel of thread
		244	IoAcquireCancelSpinLock(&oldIrqlCancel);
		245
		246	if (pciada->pBlockingIrp != (PIRP *)NULL)
		247	{
		248	// get my associated packet
		249	Irp = *pciada->pBlockingIrp;
		250
		251	if (Irp != (PIRP)NULL)
		252	{
		253	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		254	PCICC32_IRQ_RESPONSE pIrqStatus = (PCICC32_IRQ_RESPONSE )(Irp->AssociatedIrp.SystemBuffer);
		255	ULONG irp_info = sizeof(PCICC32_IRQ_RESPONSE);
		256
		257	pIrqStatus->dwInterruptFlags = pciada->dwIrqStatus;
		258	pIrqStatus->dwInterface = file_obj->uwAssociatedCC32;
		259
		260	// release the cancel routine from this Irp
		261	IoSetCancelRoutine(Irp, NULL);
		262
		263	COMPLETE_REQUEST;
		264
		265	file_obj->blockingIrp = (PIRP)NULL;
		266	}
		267
		268	pciada->pBlockingIrp = (PIRP *)NULL; // mark the storage for blocking Irp free
		269	}
		270
		271	// release the spin locks
		272	IoReleaseCancelSpinLock(oldIrqlCancel);
		273	}
		274
		275	//------------------------------------------------------------------------
		276	// all functions called from ioctl jump table
		277	//
		278
		279	//------------------------------------------------------------------------
		280	// a dummy entry because of compatibiltiy (near) WIN95 driver
		281	static NTSTATUS ioctl_dummy(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
		282	{
		283	NTSTATUS Status = STATUS_SUCCESS;
		284	ULONG irp_info = 0;
		285	PVOID pInputBuffer,pOutputBuffer;
		286	ULONG InputLength, OutputLength;
		287	char *pCommand;
		288	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		289
		290	SET_BUFFERS_METHOD_BUFFERED;
		291
		292	pCommand = (char *)pInputBuffer;
		293
		294	KdPrint(("ioctl_dummy(%d)\n", file_obj->uwAssociatedCC32));
		295
		296	// do what must be here in between -----------
		297
		298	// do what must be here in between --- end ---
		299
		300	COMPLETE_REQUEST;
		301
		302	KdPrint(("ioctl_dummy(), Status = 0x%08x\n", Status));
		303
		304	return Status;
		305	}
		306
		307	//------------------------------------------------------------------------
		308	// requests status
		309	static NTSTATUS ioctl_get_status(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
		310	{
		311	NTSTATUS Status = STATUS_SUCCESS;
		312	ULONG irp_info = sizeof(PCICC32_STATUS);
		313	PVOID pInputBuffer,pOutputBuffer;
		314	ULONG InputLength, OutputLength;
		315	PCIADA *pciada;
		316	DEVICE_EXT *pDevExt;
		317	PCICC32_STATUS *pStatus;
		318	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		319	USHORT wModuleNumber = file_obj->uwAssociatedCC32;
		320
		321	// do what must be here in between -----------
		322	pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
		323
		324	SET_BUFFERS_METHOD_BUFFERED;
		325
		326	KdPrint(("ioctl_get_status(%d)\n", wModuleNumber));
		327
		328	// do what must be here in between -----------
		329	if (OutputLength >= sizeof(PCICC32_STATUS))
		330	{
		331	USHORT temp;
		332
		333	pStatus = (PCICC32_STATUS *)pOutputBuffer;
		334
		335	pciada = pDevExt->cc32[wModuleNumber];
		336
		337	pStatus->dwInterface = wModuleNumber;
		338
		339	temp = READ_REGISTER_USHORT(pciada->pwIntCSR);
		340	pStatus->bTimeout = (temp & 0x0020) ? 1 : 0;
		341	pStatus->bInterrupt = (temp & 0x0004) ? 1 : 0;
		342	}
		343	else
		344	Status = STATUS_BUFFER_TOO_SMALL;
		345	// do what must be here in between --- end ---
		346
		347	COMPLETE_REQUEST;
		348
		349	KdPrint(("ioctl_get_status(), Status = 0x%08x\n", Status));
		350
		351	return Status;
		352	}
		353
		354	//------------------------------------------------------------------------
		355	// clears status
		356	static BOOLEAN ioctl_clear_status_kernel(PVOID pvContext)
		357	{
		358	PCIADA pciada = (PCIADA )pvContext;
		359	USHORT wCntrl;
		360
		361	// get current Cntrl - and clear interrupt
		362	wCntrl = READ_REGISTER_USHORT(pciada->pwCntrl);
		363	wCntrl &= ~0x0100; // disable
		364	WRITE_REGISTER_USHORT(pciada->pwCntrl, wCntrl);
		365	wCntrl \|= 0x0100; // enable again
		366	WRITE_REGISTER_USHORT(pciada->pwCntrl, wCntrl);
		367
		368	return TRUE;
		369	}
		370
		371	static NTSTATUS ioctl_clear_status(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
		372	{
		373	NTSTATUS Status = STATUS_SUCCESS;
		374	ULONG irp_info = 0;
		375	PVOID pInputBuffer,pOutputBuffer;
		376	ULONG InputLength, OutputLength;
		377	PCIADA *pciada;
		378	DEVICE_EXT *pDevExt;
		379	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		380	USHORT wModuleNumber = file_obj->uwAssociatedCC32;
		381
		382	// do what must be here in between -----------
		383	pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
		384
		385	SET_BUFFERS_METHOD_BUFFERED;
		386
		387	KdPrint(("ioctl_clear_status(%d)\n", wModuleNumber));
		388
		389	// do what must be here in between -----------
		390	pciada = pDevExt->cc32[wModuleNumber];
		391
		392	KeSynchronizeExecution(pciada->InterruptObject, ioctl_clear_status_kernel, pciada);
		393
		394	// do what must be here in between --- end ---
		395
		396	COMPLETE_REQUEST;
		397
		398	KdPrint(("ioctl_clear_status() OK\n"));
		399
		400	return Status;
		401	}
		402
		403	//------------------------------------------------------------------------
		404	// set parameter for this path for future access to CC32
		405	static NTSTATUS ioctl_access_para(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
		406	{
		407	NTSTATUS Status = STATUS_SUCCESS;
		408	ULONG irp_info = 0;
		409	PVOID pInputBuffer,pOutputBuffer;
		410	ULONG InputLength, OutputLength;
		411	PCICC32_ACCESS_COMMAND *pAccessPara;
		412	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		413	USHORT wModuleNumber = file_obj->uwAssociatedCC32;
		414	DEVICE_EXT pDevExt = (DEVICE_EXT )(device_Obj->DeviceExtension);
		415	PCIADA *pciada = pDevExt->cc32[wModuleNumber];
		416
		417	SET_BUFFERS_METHOD_BUFFERED;
		418
		419	KdPrint(("ioctl_access_para(%d)\n", wModuleNumber));
		420
		421	pAccessPara = (PCICC32_ACCESS_COMMAND *)pInputBuffer;
		422
		423	// do here in between what has to be done -----------------
		424	file_obj->wAccessType = pAccessPara->wAccessType;
		425	file_obj->wBlockTransfer = pAccessPara->wBlockTransfer;
		426
		427	pAccessPara->dwInterface = wModuleNumber;
		428
		429	switch (pAccessPara->wAccessType)
		430	{
		431	case WORD_ACCESS: file_obj->fRead = readWord;
		432	file_obj->fWrite = writeWord;
		433	break;
		434	case LONG_ACCESS: file_obj->fRead = readLong;
		435	file_obj->fWrite = writeLong;
		436	break;
		437	default: Status = STATUS_UNSUCCESSFUL;
		438	break;
		439	}
		440	// do here in between what has to be done end -------------
		441
		442	COMPLETE_REQUEST;
		443
		444	KdPrint(("ioctl_access_para(), Status = 0x%08x\n", Status));
		445
		446	return Status;
		447	}
		448
		449	//------------------------------------------------------------------------
		450	// allow or inhibit interrupt requests from either CC32 or thru local timeout
		451	static NTSTATUS ioctl_control_interrupts(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
		452	{
		453	NTSTATUS Status = STATUS_SUCCESS;
		454	ULONG irp_info = 0;
		455	PVOID pInputBuffer,pOutputBuffer;
		456	ULONG InputLength, OutputLength;
		457	PCICC32_IRQ_CONTROL pIrqControlIn, pIrqControlOut;
		458	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		459	USHORT wModuleNumber = file_obj->uwAssociatedCC32;
		460	DEVICE_EXT pDevExt = (DEVICE_EXT )(device_Obj->DeviceExtension);
		461	PCIADA *pciada = pDevExt->cc32[wModuleNumber];
		462
		463	SET_BUFFERS_METHOD_BUFFERED;
		464
		465	KdPrint(("ioctl_control_interrupts(%d)\n", wModuleNumber));
		466
		467	pIrqControlIn = (PCICC32_IRQ_CONTROL *)pInputBuffer;
		468	pIrqControlOut = (PCICC32_IRQ_CONTROL *)pOutputBuffer;
		469
		470	// do here in between what has to be done -----------------
		471	if (pIrqControlIn->wEnable)
		472	{
		473	// reserve the controlling of interrupts for this path
		474	if ((pciada->pIrqControlFile == (FILE_OBJ *)NULL) \|\|
		475	(pciada->pIrqControlFile == file_obj))
		476	{
		477	pciada->pIrqControlFile = file_obj;
		478	globalInterruptEnable(pciada);
		479	}
		480	else
		481	Status = STATUS_DEVICE_BUSY;
		482	}
		483	else
		484	{
		485	// nobody else is allowed to disable interrupts
		486	if (pciada->pIrqControlFile == file_obj)
		487	{
		488	pciada->pIrqControlFile = (FILE_OBJ *)NULL;
		489	globalInterruptDisable(pciada);
		490	}
		491	else
		492	Status = STATUS_DEVICE_BUSY;
		493	}
		494
		495	// give back if the user grants space
		496	if (OutputLength >= sizeof(PCICC32_IRQ_CONTROL))
		497	{
		498	pIrqControlOut->dwInterface = wModuleNumber;
		499	pIrqControlOut->wEnable = globalInterruptEnabledStatus(pciada);
		500	}
		501	// do here in between what has to be done end -------------
		502
		503	COMPLETE_REQUEST;
		504
		505	KdPrint(("ioctl_control_interrupts(), Status = 0x%08x\n", Status));
		506
		507	return Status;
		508	}
		509
		510	//------------------------------------------------------------------------
		511	// implements a blocking io-call to get irq status.
		512	static BOOLEAN ioctl_irq_status_kernel(PVOID pvContext)
		513	{
		514	IOCTL_IRQ_STATUS_CONTEXT context = (IOCTL_IRQ_STATUS_CONTEXT )pvContext;
		515	KIRQL oldIrql;
		516
		517	if (context->pciada->dwIrqStatus)
		518	{
		519	// there is a pending interrupt - return immediately
		520	KdPrint(("ioctl_irq_status(), direct return (0x%08x)\n", context->pciada->dwIrqStatus));
		521
		522	context->pIrqStatus->dwInterruptFlags = context->pciada->dwIrqStatus;
		523	context->pciada->dwIrqStatus = 0; // release pending status
		524
		525	*context->irp_info = sizeof(PCICC32_IRQ_RESPONSE);
		526	}
		527	else
		528	{
		529	// make the request blocking
		530	IoAcquireCancelSpinLock(&oldIrql);
		531
		532	if ((*context->Irp)->Cancel) // cancel while doing
		533	{
		534	KdPrint(("ioctl_irq_status(), canceled return\n"));
		535	*context->Status = STATUS_CANCELLED;
		536	}
		537	else
		538	{
		539	KdPrint(("ioctl_irq_status(), blocking\n"));
		540
		541	if (context->pciada->pBlockingIrp != (PIRP *)NULL)
		542	{
		543	// a Irp is still waiting
		544	*context->Status = STATUS_DEVICE_BUSY;
		545	}
		546	else
		547	{
		548	context->file_obj->blockingIrp = *context->Irp;
		549	context->pciada->pBlockingIrp = &context->file_obj->blockingIrp;
		550
		551	*context->Status = STATUS_PENDING;
		552
		553	// mark irp as pending and return
		554	IoMarkIrpPending(*context->Irp);
		555	IoSetCancelRoutine(*context->Irp, CancelRequest);
		556	}
		557	} // if (Irp->Cancel) ...
		558	}
		559
		560	return TRUE;
		561	}
		562
		563	static NTSTATUS ioctl_irq_status(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
		564	{
		565	NTSTATUS Status = STATUS_SUCCESS;
		566	ULONG irp_info = 0;
		567	PVOID pInputBuffer,pOutputBuffer;
		568	ULONG InputLength, OutputLength;
		569	DEVICE_EXT pDevExt = (DEVICE_EXT )(device_Obj->DeviceExtension);
		570	USHORT wModuleNumber;
		571	IOCTL_IRQ_STATUS_CONTEXT context;
		572
		573	SET_BUFFERS_METHOD_BUFFERED;
		574
		575	context.file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
		576	wModuleNumber = context.file_obj->uwAssociatedCC32;
		577	context.pciada = pDevExt->cc32[wModuleNumber];
		578	context.pIrqStatus = (PCICC32_IRQ_RESPONSE *)pOutputBuffer;
		579	context.Status = &Status;
		580	context.irp_info = &irp_info;
		581	context.Irp = &Irp;
		582
		583
		584	KdPrint(("ioctl_irq_status(%d)\n", wModuleNumber));
		585
		586	// do here in between what has to be done -----------------
		587	if (OutputLength < sizeof(PCICC32_IRQ_RESPONSE))
		588	Status = STATUS_BUFFER_TOO_SMALL;
		589	else
		590	{
		591	context.pIrqStatus->dwInterface = wModuleNumber;
		592
		593	KeSynchronizeExecution(context.pciada->InterruptObject, ioctl_irq_status_kernel, &context);
		594	}
		595	// do here in between what has to be done end -------------
		596
		597	COMPLETE_REQUEST;
		598
		599	KdPrint(("ioctl_irq_status(), Status = 0x%08x\n", Status));
		600
		601	return Status;
		602	}
		603
		604
		605	//------------------------------------------------------------------------
		606	// for test and debug purposes: direkt access to PLX LCR space
		607	static NTSTATUS ioctl_access_lcr(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
		608	{
		609	NTSTATUS Status = STATUS_SUCCESS;
		610	ULONG irp_info = 0;
		611	PVOID pInputBuffer,pOutputBuffer;
		612	ULONG InputLength, OutputLength;
		613	FILE_OBJ file_obj = (FILE_OBJ )Irp->Tail.Overlay.OriginalFileObject->FsContext;
		614	USHORT wModuleNumber = file_obj->uwAssociatedCC32;
		615	DEVICE_EXT pDevExt = (DEVICE_EXT )(device_Obj->DeviceExtension);
		616	PCIADA *pciada = pDevExt->cc32[wModuleNumber];
		617	PCICC32_LCR_ACCESS *pAccessOut;
		618	PCICC32_LCR_ACCESS *pAccessIn;
		619
		620	SET_BUFFERS_METHOD_BUFFERED;
		621
		622	KdPrint(("ioctl_access_lcr(%d)\n", wModuleNumber));
		623
		624	pAccessOut = (PCICC32_LCR_ACCESS *)pOutputBuffer;
		625	pAccessIn = (PCICC32_LCR_ACCESS *)pInputBuffer;
		626
		627	// do here in between what has to be done -----------------
		628	if (OutputLength < sizeof(PCICC32_LCR_ACCESS))
		629	Status = STATUS_BUFFER_TOO_SMALL;
		630	else
		631	{
		632	pAccessOut = pAccessIn;
		633	pAccessOut->dwInterface = wModuleNumber;
		634
		635	if (pAccessIn->wRegisterAddress <= 0x52)
		636	{
		637	// 1st part: long word accesses
		638	if (pAccessIn->bBytesLane == LONG_ACCESS)
		639	{
		640	if (pAccessIn->wRegisterAddress & 0x0003)
		641	Status = STATUS_INSTRUCTION_MISALIGNMENT;
		642	else
		643	{
		644	ULONG *pdwVirtAddress;
		645	ULONG dwDummy;
		646
		647	pdwVirtAddress = (ULONG *)((ULONG)pciada->pvVirtLcr + pAccessIn->wRegisterAddress);
		648
		649	switch (pAccessIn->bAccessMode)
		650	{
		651	case LCR_WRITE:
		652	WRITE_REGISTER_ULONG(pdwVirtAddress, pAccessIn->dwContent);
		653	pAccessOut->dwContent = READ_REGISTER_ULONG(pdwVirtAddress);
		654	break;
		655	case LCR_OR:
		656	dwDummy = READ_REGISTER_ULONG(pdwVirtAddress);
		657	dwDummy \|= pAccessIn->dwContent;
		658	WRITE_REGISTER_ULONG(pdwVirtAddress, dwDummy);
		659	pAccessOut->dwContent = READ_REGISTER_ULONG(pdwVirtAddress);
		660	break;
		661	case LCR_AND:
		662	dwDummy = READ_REGISTER_ULONG(pdwVirtAddress);
		663	dwDummy &= pAccessIn->dwContent;
		664	WRITE_REGISTER_ULONG(pdwVirtAddress, dwDummy);
		665	pAccessOut->dwContent = READ_REGISTER_ULONG(pdwVirtAddress);
		666	break;
		667	case LCR_WRITE_ONLY:
		668	WRITE_REGISTER_ULONG(pdwVirtAddress, pAccessIn->dwContent);
		669	break;
		670	case LCR_READ:
		671	pAccessOut->dwContent = READ_REGISTER_ULONG(pdwVirtAddress);
		672	break;
		673
		674	default: Status = STATUS_ILLEGAL_INSTRUCTION;
		675	}
		676	}
		677	}
		678
		679	// 2nd part: short word accesses
		680	if (pAccessIn->bBytesLane == WORD_ACCESS)
		681	{
		682	if (pAccessIn->wRegisterAddress & 0x0001)
		683	Status = STATUS_INSTRUCTION_MISALIGNMENT;
		684	else
		685	{
		686	USHORT *pwVirtAddress;
		687	USHORT wDummy;
		688
		689	pwVirtAddress = (USHORT *)((ULONG)pciada->pvVirtLcr + pAccessIn->wRegisterAddress);
		690
		691	switch (pAccessIn->bAccessMode)
		692	{
		693	case LCR_WRITE:
		694	WRITE_REGISTER_USHORT(pwVirtAddress, (USHORT)pAccessIn->dwContent);
		695	pAccessOut->dwContent = READ_REGISTER_USHORT(pwVirtAddress);
		696	break;
		697	case LCR_OR:
		698	wDummy = READ_REGISTER_USHORT(pwVirtAddress);
		699	wDummy \|= (USHORT)pAccessIn->dwContent;
		700	WRITE_REGISTER_USHORT(pwVirtAddress, wDummy);
		701	pAccessOut->dwContent = READ_REGISTER_USHORT(pwVirtAddress);
		702	break;
		703	case LCR_AND:
		704	wDummy = READ_REGISTER_USHORT(pwVirtAddress);
		705	wDummy &= (USHORT)pAccessIn->dwContent;
		706	WRITE_REGISTER_USHORT(pwVirtAddress, wDummy);
		707	pAccessOut->dwContent = READ_REGISTER_USHORT(pwVirtAddress);
		708	break;
		709	case LCR_WRITE_ONLY:
		710	WRITE_REGISTER_USHORT(pwVirtAddress, (USHORT)pAccessIn->dwContent);
		711	break;
		712	case LCR_READ:
		713	pAccessOut->dwContent = READ_REGISTER_USHORT(pwVirtAddress);
		714	break;
		715
		716	default: Status = STATUS_ILLEGAL_INSTRUCTION;
		717	break;
		718	}
		719	}
		720	}
		721
		722	// 3rd part: check illegal byte lanes
		723	if (!((pAccessIn->bBytesLane == LONG_ACCESS) \|\| (pAccessIn->bBytesLane == WORD_ACCESS)))
		724	Status = STATUS_ILLEGAL_INSTRUCTION;
		725	}
		726	else
		727	Status = STATUS_ILLEGAL_INSTRUCTION;
		728	}
		729	// do here in between what has to be done end -------------
		730
		731	if (Status == STATUS_SUCCESS)
		732	irp_info = sizeof(PCICC32_LCR_ACCESS);
		733
		734	COMPLETE_REQUEST;
		735
		736	KdPrint(("ioctl_access_lcr(), Status = 0x%08x\n", Status));
		737
		738	return Status;
		739	}
		740
		741
		742	//------------------------------------------------------------------------
		743	// the ultimate jumptable for ioctl
		744	//
		745	NTSTATUS (*ioctl[])(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack) =
		746	{
		747	ioctl_dummy, // 0
		748	ioctl_dummy, // 4
		749	ioctl_get_status, // 8
		750	ioctl_clear_status, // 0x0c
		751	ioctl_access_para, // 0x10
		752	ioctl_control_interrupts, // 0x14
		753	ioctl_dummy, // 0x18
		754	ioctl_irq_status, // 0x1c
		755	ioctl_access_lcr // 0x20
		756	};
		757

Subversion Repositories f9daq

(root)//drivers/wiener_pcicc32/SOURCE/pcicc32_io.c – Rev 176