WebSVN - f9daq - Blame - Rev 23 - /wiener_pcicc32/SOURCE/pcicc32

Rev	Author	Line No.	Line
23	f9daq	1	//-------------------------------------------------------------------------
		2	// WINNT driver for PCICC32 (CAMAC) interface of ARW Elektronik, Germany --
		3	// the main body of the driver
		4	//
		5	// (c) 2000-2002 ARW Elektronik
		6	//
		7	// this source code is published under GPL (Open Source). You can use, redistribute 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 out of pcivme sources AR 25.03.2000
		17	// added IRQ handling AR 24.02.2001
		18	// Added AUTOREAD functionality AR 17.03.2001
		19	// Added LCR_READ AR 31.03.2001
		20	// resource allocation registers idle entries too AR 25.11.2001
		21	// changed making procedure (only VCC > 6.0) AR 30.05.2002
		22	// totally rearanged resource alloc for WIN2000 AR 01.06.2002
		23	// version 2.14 eleminates PLXBUG in WIN2000 AR 05.06.2002
		24	// added KeSynchronizeExecution for interrupt sync AR 16.06.2002
		25	//
		26
		27	//------------------------------------------------------------------------
		28	// DEFINES
		29	//
		30	#ifndef DWORD
		31	#define DWORD ULONG
		32	#endif
		33
		34	#ifndef WORD
		35	#define WORD USHORT
		36	#endif
		37
		38	#define CTL_INDEX(x) ((x >> 2) & 0xFF) // get user control code as index
		39	#define RESOURCE_ENTRY_COUNT 6 // WIN2000 forces to claim all entries
		40
		41	#define DOS_DEVICE_NAME L"\\DosDevices\\PCICC32:"
		42
		43	//-------------------------------------------------------------------------
		44	// INCLUDES
		45	//
		46
		47	#include <ntddk.h>
		48	#include <devioctl.h>
		49	// #include <wdm.h>
		50
		51	#include <pcicc32_drv.h>
		52	#include <pcicc32.h>
		53	#include <pcicc32_v.h>
		54	#include <pcicc32_i.h>
		55	#include <pcicc32_io.h>
		56
		57
		58	//------------------------------------------------------------------------
		59	// TYPEDEFS
		60	//
		61	typedef struct
		62	{
		63	FILE_OBJ *file_obj;
		64	PCIADA *pciada;
		65	PVOID pOutputBuffer;
		66	PVOID pInputBuffer;
		67	ULONG Address;
		68	DWORD Length;
		69	} SYNC_CONTEXT;
		70
		71	//------------------------------------------------------------------------
		72	// GLOBALS
		73	//
		74
		75	//------------------------------------------------------------------------
		76	// FUNCTIONS
		77	//
		78
		79	//------------------------------------------------------------------------
		80	// for debug only - print interrupt line
		81	//
		82	#if DBG
		83	void PrintInterruptLine(int Bus, int Slot)
		84	{
		85	PCI_COMMON_CONFIG pci_config;
		86
		87	HalGetBusData( PCIConfiguration, // Bustype
		88	Bus, // PCI-Busnumber
		89	Slot, // Slotnumber
		90	(PVOID) &(pci_config), // Pointer for the PCI-Information
		91	sizeof(PCI_COMMON_CONFIG));
		92
		93	KdPrint(("Irql: %d\n", pci_config.u.type0.InterruptLine));
		94	}
		95	#endif
		96
		97	//------------------------------------------------------------------------
		98	// get the cc32 number out of the filename
		99	//
		100	NTSTATUS InterpreteFileName(PCHAR name, int *nCC32)
		101	{
		102	char *ptr = name;
		103	char *n = "cc32_";
		104	int h = -1; // high part
		105	int l = -1; // low part
		106
		107	if (*ptr == '\\') ptr++; // jump over leading ...
		108
		109	while (*n) // compare the basename
		110	if (n == tolower(ptr))
		111	{
		112	n++;
		113	ptr++;
		114	}
		115	else
		116	return STATUS_NO_SUCH_FILE;
		117
		118	h = *ptr - '0'; // get the number
		119	ptr++;
		120	l = *ptr - '0';
		121
		122	if (*ptr == 0) // still over the end ??
		123	{
		124	l = h;
		125	h = 0;
		126	}
		127	else
		128	ptr++;
		129
		130	if ((h < 0) \|\| (l < 0) \|\| (*ptr != 0)) // anything wrong ??
		131	return STATUS_NO_SUCH_FILE;
		132
		133	nCC32 = (h 10) + l; // calculate number
		134
		135	if (*nCC32 >= PCICC32_MAX_CC32) // out of range ??
		136	return STATUS_NO_SUCH_FILE;
		137
		138	return STATUS_SUCCESS;
		139	}
		140
		141	//------------------------------------------------------------------------
		142	// the ultimate driver unload
		143	VOID PCICC32Unload(PDRIVER_OBJECT driverObj)
		144	{
		145	int i;
		146	UNICODE_STRING symbol_name;
		147	DEVICE_EXT ext = (DEVICE_EXT)(driverObj->DeviceObject->DeviceExtension);
		148	int nPCIADAs = ext->nPCIADAs;
		149	PCIADA *pciada;
		150
		151	KdPrint(("PCICC32Unload()\n"));
		152
		153	switch (ext->nInitState)
		154	{
		155	case 8:
		156	case 7:
		157	case 6:
		158	// stop interrupts and shut off
		159	PCICC32DeInitPCIADAs(driverObj->DeviceObject);
		160	PCICC32DisConnectInterrupt(driverObj->DeviceObject);
		161	case 5:
		162	// KeInitializeDpc has no counterpart
		163	case 4:
		164	for (i = 0; i < nPCIADAs; i++)
		165	{
		166	pciada = &ext->pciada[i];
		167	if (pciada->pvVirtLcr != NULL)
		168	MmUnmapIoSpace(pciada->pvVirtLcr, LCR_SPACE);
		169	if (pciada->pvVirtIfr != NULL)
		170	MmUnmapIoSpace(pciada->pvVirtIfr, IFR_SPACE);
		171	}
		172	case 3:
		173	// HalGetInterruptVector has no counterpart
		174	case 2:
		175	// HalTranslateBusAddress has no counterpart
		176	case 1:
		177	PCICC32FreeResources(driverObj->DeviceObject);
		178	default:
		179	case 0:
		180	RtlInitUnicodeString(&symbol_name, DOS_DEVICE_NAME);
		181
		182	// delete the symbolicLink in the registry
		183	IoDeleteSymbolicLink( &symbol_name);
		184
		185	// delete the deviceObject
		186	IoDeleteDevice(driverObj->DeviceObject);
		187	}
		188
		189	KdPrint(("PCICC32Unload() OK.\n"));
		190	}
		191
		192
		193	//------------------------------------------------------------------------
		194	// called at CreateFile()
		195	NTSTATUS PCICC32Open(PDEVICE_OBJECT deviceObj, PIRP Irp)
		196	{
		197	NTSTATUS result = STATUS_SUCCESS;
		198	ANSI_STRING name;
		199	int nCC32;
		200	int i;
		201	DEVICE_EXT pDevExt = (DEVICE_EXT )(deviceObj->DeviceExtension);
		202	PCIADA *pciada;
		203	FILE_OBJ *file_obj;
		204
		205	name.Buffer = NULL;
		206	name.MaximumLength = 80;
		207
		208	result = RtlUnicodeStringToAnsiString(&name, &(Irp->Tail.Overlay.OriginalFileObject->FileName), TRUE);
		209	if (result != STATUS_SUCCESS) goto fin;
		210
		211	KdPrint(("PCICC32Open(%s)\n", name.Buffer));
		212
		213	result = InterpreteFileName(name.Buffer, &nCC32);
		214	if (result != STATUS_SUCCESS) goto fin;
		215
		216	KdPrint(("PCICC32Open(%d)\n", nCC32));
		217	RtlFreeAnsiString(&name);
		218
		219	file_obj = (FILE_OBJ *)ExAllocatePool(NonPagedPool, sizeof(FILE_OBJ));
		220	if (file_obj == (FILE_OBJ *)NULL)
		221	{
		222	result = STATUS_NO_MEMORY;
		223	goto fin;
		224	}
		225
		226	file_obj->uwAssociatedCC32 = nCC32;
		227
		228	Irp->Tail.Overlay.OriginalFileObject->FsContext = (PVOID)file_obj;
		229
		230	result = PCICC32ScanCC32(deviceObj);
		231	if (result != STATUS_SUCCESS) goto fin;
		232
		233	for (i = 0; i < pDevExt->nPCIADAs; i++)
		234	{
		235	pciada = &pDevExt->pciada[i];
		236
		237	if (pciada->wModuleNumber == nCC32)
		238	{
		239	pDevExt->cc32[nCC32] = pciada; // create association
		240	pciada->dwLinkCount++;
		241
		242	enableCC32(pciada);
		243	break;
		244	}
		245	}
		246
		247	if (i >= pDevExt->nPCIADAs)
		248	{
		249	result = STATUS_NO_SUCH_FILE;
		250	goto fin;
		251	}
		252
		253	fin:
		254	Irp->IoStatus.Status = result;
		255	Irp->IoStatus.Information = 0;
		256	IoCompleteRequest(Irp, IO_NO_INCREMENT);
		257
		258	return result;
		259	}
		260
		261	//------------------------------------------------------------------------
		262	// called at close()
		263	NTSTATUS PCICC32Close(PDEVICE_OBJECT deviceObj, PIRP Irp)
		264	{
		265	DEVICE_EXT pDevExt = (DEVICE_EXT )(deviceObj->DeviceExtension);
		266	FILE_OBJ file_obj = (FILE_OBJ )NULL;
		267	PCIADA *pciada;
		268
		269	file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
		270
		271	KdPrint(("PCICC32Close(%d)\n", file_obj->uwAssociatedCC32));
		272
		273	if (file_obj != (FILE_OBJ *)NULL)
		274	{
		275	pciada = pDevExt->cc32[file_obj->uwAssociatedCC32];
		276	pciada->dwLinkCount--;
		277
		278	// disable interrupts when closing
		279	if (pciada->pIrqControlFile == file_obj)
		280	{
		281	pciada->pIrqControlFile = (FILE_OBJ *)NULL;
		282	globalInterruptDisable(pciada);
		283	}
		284
		285	// cancel any blocking Irp origin from this file
		286	if (file_obj->blockingIrp != (PIRP)NULL)
		287	file_obj->blockingIrp = (PIRP)NULL;
		288
		289	if (pciada->pBlockingIrp == &file_obj->blockingIrp)
		290	pciada->pBlockingIrp = (PIRP *)NULL;
		291
		292	if (!pciada->dwLinkCount)
		293	disableCC32(pciada);
		294
		295	ExFreePool(file_obj);
		296	Irp->Tail.Overlay.OriginalFileObject->FsContext = (FILE_OBJ *)NULL;
		297	}
		298
		299	KdPrint(("PCICC32Close OK\n"));
		300
		301	Irp->IoStatus.Status = STATUS_SUCCESS;
		302	Irp->IoStatus.Information = 0;
		303	IoCompleteRequest(Irp, IO_NO_INCREMENT);
		304
		305	return STATUS_SUCCESS;
		306	}
		307
		308	//------------------------------------------------------------------------
		309	// called at
		310	NTSTATUS PCICC32Shutdown(PDEVICE_OBJECT deviceObj, PIRP irp)
		311	{
		312	KdPrint(("PCICC32Shutdown()\n"));
		313
		314	// deinit interfaces and interrupts
		315	PCICC32DeInitPCIADAs(deviceObj);
		316
		317	KdPrint(("PCICC32Shutdown() OK\n"));
		318
		319	return STATUS_SUCCESS;
		320	}
		321
		322	//------------------------------------------------------------------------
		323	// called at ioctl()
		324	NTSTATUS PCICC32DeviceControl(PDEVICE_OBJECT deviceObj, PIRP Irp)
		325	{
		326	PIO_STACK_LOCATION IrpStack;
		327	int nIndex;
		328
		329	IrpStack = IoGetCurrentIrpStackLocation(Irp);
		330	nIndex = CTL_INDEX(IrpStack->Parameters.DeviceIoControl.IoControlCode);
		331
		332	KdPrint(("PCICC32DeviceControl(%d / 0x%08x)\n", nIndex, Irp->Tail.Overlay.OriginalFileObject));
		333
		334	if (nIndex > CTL_INDEX(PCICC32_LAST_CTL_CODE))
		335	{
		336	KdPrint(("LastIndex(%d)\n", CTL_INDEX(PCICC32_LAST_CTL_CODE)));
		337	Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
		338	Irp->IoStatus.Information = 0;
		339	IoCompleteRequest(Irp,IO_NO_INCREMENT);
		340
		341	KdPrint(("PCICC32DeviceControl() FAIL.\n"));
		342
		343	return STATUS_UNSUCCESSFUL;
		344	}
		345
		346	return ioctl[nIndex](deviceObj, Irp, IrpStack);
		347	}
		348
		349
		350	//------------------------------------------------------------------------
		351	// called at read()
		352	static BOOLEAN PCICC32Read_kernel(PVOID pvContext)
		353	{
		354	register SYNC_CONTEXT context = (SYNC_CONTEXT )pvContext;
		355	register ULONG i = 0;
		356	USHORT wCntrl;
		357
		358	wCntrl = READ_REGISTER_USHORT(context->pciada->pwCntrl);
		359	if (context->file_obj->wBlockTransfer & AUTOREAD)
		360	{
		361	wCntrl &= ~0x0004; // enable autoread - set bit to 0
		362	WRITE_REGISTER_USHORT(context->pciada->pwCntrl, wCntrl);
		363	}
		364
		365	// do the read ---
		366	if (context->file_obj->wBlockTransfer & UNTIL_NOT_Q)
		367	{
		368	// read first time to get Q information
		369	register ULONG tempBuffer = READ_REGISTER_ULONG((ULONG *)context->Address);
		370
		371	if (context->file_obj->wAccessType == WORD_ACCESS)
		372	{
		373	PUSHORT pwBuffer = (PUSHORT)context->pOutputBuffer;
		374	PUSHORT pwBufEnd = (PUSHORT)((PUCHAR)context->pOutputBuffer + context->Length);
		375
		376	while ((tempBuffer & 0x80000000) && (pwBuffer < pwBufEnd))
		377	{
		378	*pwBuffer++ = (USHORT)tempBuffer;
		379	tempBuffer = READ_REGISTER_ULONG((ULONG *)context->Address); // read the same address multiple times as long to get Q
		380	i++;
		381	}
		382	}
		383	else
		384	{
		385	// LONG_ACCESS
		386	PULONG pdwBuffer = (PULONG)context->pOutputBuffer;
		387	PULONG pdwBufEnd = (PULONG)((PUCHAR)context->pOutputBuffer + context->Length);
		388
		389	while ((tempBuffer & 0x80000000) && (pdwBuffer < pdwBufEnd))
		390	{
		391	*pdwBuffer++ = tempBuffer;
		392	tempBuffer = READ_REGISTER_ULONG((ULONG *)context->Address); // read the same address multiple times as long to get Q
		393	i++;
		394	}
		395	}
		396
		397	i *= context->file_obj->wAccessType;
		398
		399	KdPrint(("UNTIL_NOT_Q, 0x%08x bytes read\n", i));
		400	}
		401	else // no UNTIL_NOT_Q
		402	{
		403	while (i < context->Length)
		404	{
		405	context->file_obj->fRead((void )((PUCHAR)context->pOutputBuffer + i), (void )context->Address); // read the same address multiple times
		406	i += context->file_obj->wAccessType;
		407	}
		408	}
		409
		410	// disable autoread unconditionally - set bit to 1
		411	wCntrl \|= 0x0004;
		412	WRITE_REGISTER_USHORT(context->pciada->pwCntrl, wCntrl);
		413
		414	context->Length = i;
		415
		416	return TRUE;
		417	}
		418
		419	NTSTATUS PCICC32Read(PDEVICE_OBJECT device_Obj, PIRP Irp)
		420	{
		421	NTSTATUS Status = STATUS_SUCCESS;
		422	PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
		423	DEVICE_EXT pDevExt = (DEVICE_EXT )(device_Obj->DeviceExtension);
		424	SYNC_CONTEXT context;
		425
		426	context.file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
		427	context.pciada = pDevExt->cc32[context.file_obj->uwAssociatedCC32];
		428	context.pOutputBuffer = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));
		429	context.Address = IrpStack->Parameters.Read.ByteOffset.LowPart;
		430	context.Length = 0;
		431
		432	KdPrint(("PCICC32Read(%d)\n", context.file_obj->uwAssociatedCC32));
		433
		434	if (context.Address > IFR_SPACE)
		435	Status = STATUS_ACCESS_VIOLATION;
		436	else
		437	{
		438	// do here in between what has to be done -----------------
		439	context.Length = IrpStack->Parameters.Read.Length;
		440	KdPrint(("Address = 0x%08x, Length = 0x%08x\n", context.Address, context.Length));
		441	context.Address = (ULONG)context.pciada->pvVirtIfr + context.Address;
		442
		443	KeSynchronizeExecution(context.pciada->InterruptObject, PCICC32Read_kernel, &context);
		444	// do here in between what has to be done end -------------
		445	}
		446
		447	Irp->IoStatus.Status = Status;
		448	Irp->IoStatus.Information = context.Length;
		449	IoCompleteRequest(Irp,IO_NO_INCREMENT);
		450
		451	KdPrint(("PCICC32Read(), Status = 0x%08x\n", Status));
		452
		453	return Status;
		454	}
		455
		456
		457	//------------------------------------------------------------------------
		458	// called at write()
		459	static BOOLEAN PCICC32Write_kernel(PVOID pvContext)
		460	{
		461	register SYNC_CONTEXT context = (SYNC_CONTEXT )pvContext;
		462	register ULONG i = 0;
		463
		464	// do the write ---
		465	while (i < context->Length)
		466	{
		467	context->file_obj->fWrite((void )context->Address, (void )((PUCHAR)context->pInputBuffer + i)); // write the same address multiple times
		468	i += context->file_obj->wAccessType;
		469	}
		470
		471	context->Length = i;
		472
		473	return TRUE;
		474	}
		475
		476	NTSTATUS PCICC32Write(PDEVICE_OBJECT device_Obj, PIRP Irp)
		477	{
		478	NTSTATUS Status = STATUS_SUCCESS;
		479	PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
		480	DEVICE_EXT pDevExt = (DEVICE_EXT )(device_Obj->DeviceExtension);
		481	SYNC_CONTEXT context;
		482
		483	context.file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
		484	context.pciada = pDevExt->cc32[context.file_obj->uwAssociatedCC32];
		485	context.pInputBuffer = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));
		486	context.Address = IrpStack->Parameters.Read.ByteOffset.LowPart;
		487	context.Length = 0;
		488
		489	KdPrint(("PCICC32Write(%d)\n", context.file_obj->uwAssociatedCC32));
		490
		491	if (context.Address > IFR_SPACE)
		492	Status = STATUS_ACCESS_VIOLATION;
		493	else
		494	{
		495	register ULONG i = 0;
		496
		497	// do here in between what has to be done -----------------
		498	context.Length = IrpStack->Parameters.Read.Length;
		499	KdPrint(("Address = 0x%08x, Length = 0x%08x\n", context.Address, context.Length));
		500	context.Address = (ULONG)context.pciada->pvVirtIfr + context.Address;
		501
		502	KeSynchronizeExecution(context.pciada->InterruptObject, PCICC32Write_kernel, &context);
		503	// do here in between what has to be done end -------------
		504	}
		505
		506
		507	Irp->IoStatus.Status = Status;
		508	Irp->IoStatus.Information = context.Length;
		509	IoCompleteRequest(Irp,IO_NO_INCREMENT);
		510
		511	KdPrint(("PCICC32Write(), Status = 0x%08x\n", Status));
		512
		513	return Status;
		514	}
		515
		516	//------------------------------------------------------------------------
		517	// search for pciada's
		518	//
		519	NTSTATUS SearchDevices(PDEVICE_OBJECT device_Obj)
		520	{
		521	PCI_SLOT_NUMBER SlotNumber;
		522	PCI_COMMON_CONFIG pci_config;
		523	PCIADA *pciada;
		524	ULONG length;
		525	int *found;
		526	int i,j,k;
		527
		528	KdPrint(("SearchDevices()\n"));
		529
		530	// prepare structures ----------------------------------------
		531	found = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->nPCIADAs;
		532	*found = 0;
		533	for (i = 0; i < PCICC32_MAX_PCIADA; i++)
		534	{
		535	pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
		536
		537	pciada->Bus = -1;
		538	pciada->Slot.u.AsULONG = 0xFFFFFFFF;
		539	}
		540
		541	// search for pciada's ---------------------------------------
		542	SlotNumber.u.bits.Reserved = 0;
		543
		544	for (j = 0; j < PCI_MAX_BUSES; j++)
		545	{
		546	for (i = 0; i < PCI_MAX_DEVICES; i++)
		547	{
		548	SlotNumber.u.bits.DeviceNumber = i;
		549	for (k = 0; k < PCI_MAX_FUNCTION; k++)
		550	{
		551	SlotNumber.u.bits.FunctionNumber = k;
		552	length = HalGetBusData( PCIConfiguration, // Bustype
		553	j, // PCI-Busnumber
		554	SlotNumber.u.AsULONG, // Slotnumber
		555	(PVOID) &(pci_config), // Pointer for the PCI-Information
		556	sizeof(PCI_COMMON_CONFIG) );
		557
		558	if ((pci_config.VendorID == PCICC32_VENDOR_ID) &&
		559	(pci_config.DeviceID == PCICC32_DEVICE_ID) &&
		560	(pci_config.u.type0.SubSystemID == PCICC32_SUBSYS_ID) &&
		561	(pci_config.u.type0.SubVendorID == PCICC32_SUBVEN_ID) &&
		562	(pci_config.u.type0.BaseAddresses[3]))
		563	{
		564	pciada = &((DEVICE_EXT)(device_Obj->DeviceExtension))->pciada[found];
		565
		566	memcpy(&pciada->PCIDevice, &pci_config, sizeof(pci_config));
		567	pciada->Slot = SlotNumber;
		568	pciada->Bus = j;
		569
		570	KdPrint(("PCIADA found @ Bus/Slot %d/%d.\n", pciada->Bus, pciada->Slot.u.AsULONG));
		571
		572	(*found)++;
		573	if (*found >= PCICC32_MAX_PCIADA) return STATUS_SUCCESS;
		574	}
		575	}
		576	}
		577	}
		578
		579	return STATUS_SUCCESS;
		580	}
		581
		582	//---------------------------------------------------------------
		583	// function to call for bug fix of PLX9050 build in bug
		584	//
		585	NTSTATUS PLX9050BugFix(PDEVICE_OBJECT device_Obj)
		586	{
		587	DEVICE_EXT DeviceExtension = (DEVICE_EXT)device_Obj->DeviceExtension;
		588	int i;
		589	ULONG dwData;
		590	PCIADA *pciada;
		591
		592	KdPrint(("PLX9050BugFix()\n"));
		593
		594	for (i = 0; i < DeviceExtension->nPCIADAs; i++)
		595	{
		596	pciada = &DeviceExtension->pciada[i];
		597
		598	if ((dwData = pciada->PCIDevice.u.type0.BaseAddresses[0]) & 0x80)
		599	{
		600	KdPrint(("Changing address 0:0x%p with 4:0x%p\n",
		601	pciada->PCIDevice.u.type0.BaseAddresses[0],
		602	pciada->PCIDevice.u.type0.BaseAddresses[4]));
		603
		604	pciada->PCIDevice.u.type0.BaseAddresses[0] = // exchange
		605	pciada->PCIDevice.u.type0.BaseAddresses[4];
		606	pciada->PCIDevice.u.type0.BaseAddresses[4] = dwData;
		607
		608	if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
		609	pciada->Slot.u.AsULONG,
		610	(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[0],
		611	0x10, 4) != 4)
		612	return STATUS_UNSUCCESSFUL;
		613
		614	if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
		615	pciada->Slot.u.AsULONG,
		616	(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[4],
		617	0x20, 4) != 4)
		618	return STATUS_UNSUCCESSFUL;
		619	}
		620
		621	if ((dwData = pciada->PCIDevice.u.type0.BaseAddresses[1]) & 0x80)
		622	{
		623	KdPrint(("Changing address 1:0x%p with 5:0x%p\n",
		624	pciada->PCIDevice.u.type0.BaseAddresses[1],
		625	pciada->PCIDevice.u.type0.BaseAddresses[5]));
		626
		627	pciada->PCIDevice.u.type0.BaseAddresses[1] = // exchange
		628	pciada->PCIDevice.u.type0.BaseAddresses[5];
		629	pciada->PCIDevice.u.type0.BaseAddresses[5] = dwData;
		630
		631	if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
		632	pciada->Slot.u.AsULONG,
		633	(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[1],
		634	0x14, 4) != 4)
		635	return STATUS_UNSUCCESSFUL;
		636
		637	if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
		638	pciada->Slot.u.AsULONG,
		639	(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[5],
		640	0x24, 4) != 4)
		641	return STATUS_UNSUCCESSFUL;
		642	}
		643	}
		644
		645	return STATUS_SUCCESS;
		646	}
		647
		648
		649	//------------------------------------------------------------------------
		650	// reserve resources for PCIADAs
		651	//
		652	NTSTATUS PCICC32ExtractResources(PCIADA *pciada, PCM_RESOURCE_LIST pList)
		653	{
		654	PCM_RESOURCE_LIST pResourceList;
		655	PCM_FULL_RESOURCE_DESCRIPTOR pFullDescriptor;
		656	PCM_PARTIAL_RESOURCE_LIST pPartialList;
		657	PCM_PARTIAL_RESOURCE_DESCRIPTOR pPartialDescriptor;
		658	int i;
		659	int bug = 0;
		660
		661	KdPrint(("PCICC32ExtractResources()\n"));
		662
		663	pResourceList = pList;
		664	pFullDescriptor = pResourceList->List;
		665	pPartialList = &pFullDescriptor->PartialResourceList;
		666
		667	for (i=0; i<(int)pPartialList->Count; i++)
		668	{
		669	pPartialDescriptor = &pPartialList->PartialDescriptors[i];
		670	switch (pPartialDescriptor->Type)
		671	{
		672	case CmResourceTypeInterrupt:
		673	pciada->Irql = (KIRQL)pPartialDescriptor->u.Interrupt.Level;
		674	pciada->Vector = pPartialDescriptor->u.Interrupt.Vector;
		675	pciada->Affinity = pPartialDescriptor->u.Interrupt.Affinity;
		676
		677	KdPrint(("Irq : Irql: %d, Vector: %d, Affinity: %d\n",
		678	pciada->Irql, pciada->Vector, pciada->Affinity));
		679	break;
		680	case CmResourceTypeDma:
		681	KdPrint(("Dma : \n"));
		682	break;
		683	case CmResourceTypePort:
		684
		685	KdPrint(("Port : 0x%p\n", pPartialDescriptor->u.Port.Start));
		686	break;
		687	case CmResourceTypeMemory:
		688	// special handling of PLXBUG here because of WIN2000
		689	// WIN2000 doesn't recognize late address changes
		690	if (!bug)
		691	{
		692	if (i == 0)
		693	{
		694	pciada->pvPhysLcr = pPartialDescriptor->u.Memory.Start;
		695
		696	if (pciada->pvPhysLcr.LowPart & 0x80)
		697	bug = 1;
		698	}
		699	}
		700	else
		701	{
		702	if (i == 3)
		703	pciada->pvPhysLcr = pPartialDescriptor->u.Memory.Start;
		704	}
		705
		706	if (i == 2)
		707	pciada->pvPhysIfr = pPartialDescriptor->u.Memory.Start;
		708
		709	KdPrint(("Memory : 0x%p\n", (PUCHAR)pPartialDescriptor->u.Memory.Start.LowPart));
		710	break;
		711	}
		712	}
		713
		714	if (pciada->Irql == 0)
		715	return STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT;
		716
		717	KdPrint(("PCICC32ExtractResources() OK.\n"));
		718
		719	return STATUS_SUCCESS;
		720	}
		721
		722	NTSTATUS PCICC32ReserveResources(PDEVICE_OBJECT device_Obj)
		723	{
		724	PCM_RESOURCE_LIST pList = NULL;
		725	NTSTATUS result = STATUS_SUCCESS;
		726	int i;
		727	DEVICE_EXT pDevExt = (DEVICE_EXT)(device_Obj->DeviceExtension);
		728	int nPCIADAs = pDevExt->nPCIADAs;
		729	PCIADA *pciada;
		730	UNICODE_STRING DriverClassName;
		731
		732	KdPrint(("PCICC32ReserveResources()\n"));
		733
		734	// prepare resource claiming
		735	RtlInitUnicodeString(&DriverClassName, L"PCICC32");
		736
		737	// cycle through all busses and slots assigned to PCIADAs
		738	for (i = 0; i < nPCIADAs; i++)
		739	{
		740	pciada = &pDevExt->pciada[i];
		741
		742	result = HalAssignSlotResources(NULL, &DriverClassName, device_Obj->DriverObject, device_Obj,
		743	PCIBus, pciada->Bus, pciada->Slot.u.AsULONG, &pList);
		744
		745	if (result != STATUS_SUCCESS)
		746	break;
		747
		748	result = PCICC32ExtractResources(pciada, pList);
		749
		750	if (result != STATUS_SUCCESS)
		751	break;
		752	}
		753
		754	// its my part to free allocated resources
		755	ExFreePool(pList);
		756
		757	KdPrint(("PCICC32ReserveResources(0x%08x)\n", result));
		758
		759	return result;
		760	};
		761
		762	//------------------------------------------------------------------------
		763	// free resources from PCIADAs
		764	//
		765	NTSTATUS PCICC32FreeResources(PDEVICE_OBJECT device_Obj)
		766	{
		767	CM_RESOURCE_LIST ResList;
		768	BOOLEAN bConflict;
		769	UNICODE_STRING DriverClassName;
		770
		771	KdPrint(("PCICC32FreeResources()\n"));
		772
		773	RtlInitUnicodeString(&DriverClassName, L"PCICC32");
		774
		775	ResList.Count = 0;
		776
		777	IoReportResourceUsage(&DriverClassName, device_Obj->DriverObject,
		778	&ResList, sizeof(ResList), device_Obj,
		779	NULL, 0, FALSE, &bConflict);
		780	return STATUS_SUCCESS;
		781	};
		782
		783
		784	//------------------------------------------------------------------------
		785	// translate memory resources to neutral for PCIADAs
		786	//
		787	NTSTATUS PCICC32TranslateBusAddresses(PDEVICE_OBJECT device_Obj)
		788	{
		789	int i;
		790	NTSTATUS result = STATUS_SUCCESS;
		791	int nPCIADAs = ((DEVICE_EXT*)(device_Obj->DeviceExtension))->nPCIADAs;
		792	ULONG memType0, memType2;
		793	PCIADA *pciada;
		794
		795	KdPrint(("TranslateBusAddresseses()\n"));
		796	for (i = 0; i < nPCIADAs; i++)
		797	{
		798	pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
		799
		800	memType0 = memType2 = 0;
		801
		802	if (!(HalTranslateBusAddress(PCIBus, pciada->Bus, pciada->pvPhysLcr, &memType0,
		803	&pciada->pvPhysLcr)) \|\|
		804	!(HalTranslateBusAddress(PCIBus, pciada->Bus, pciada->pvPhysIfr, &memType2,
		805	&pciada->pvPhysIfr)))
		806	{
		807	result = STATUS_UNSUCCESSFUL;
		808	break;
		809	}
		810
		811	if ((memType0) \|\| (memType2))
		812	{
		813	result = STATUS_UNSUCCESSFUL;
		814	break;
		815	}
		816	}
		817	return result;
		818	}
		819
		820	//------------------------------------------------------------------------
		821	// map address spaces to virtual addresses
		822	//
		823	NTSTATUS PCICC32MapIOspaces(PDEVICE_OBJECT device_Obj)
		824	{
		825	int i;
		826	DEVICE_EXT pDevExt = (DEVICE_EXT)device_Obj->DeviceExtension;
		827	int nPCIADAs = pDevExt->nPCIADAs;
		828	PCIADA *pciada;
		829
		830	KdPrint(("PCICC32MapIOspaces()\n"));
		831
		832	for (i = 0; i < nPCIADAs; i++)
		833	{
		834	pciada = &pDevExt->pciada[i];
		835
		836	if ((pciada->pvVirtLcr = MmMapIoSpace(pciada->pvPhysLcr, LCR_SPACE, FALSE)) == NULL)
		837	return STATUS_UNSUCCESSFUL;
		838	if ((pciada->pvVirtIfr = MmMapIoSpace(pciada->pvPhysIfr, IFR_SPACE, FALSE)) == NULL)
		839	return STATUS_UNSUCCESSFUL;
		840
		841	KdPrint(("PCIADA %d: LCR 0x%08x IFR 0x%08x\n", i, pciada->pvVirtLcr, pciada->pvVirtIfr));
		842
		843	pciada->pwIntCSR = (PUSHORT)((PUCHAR)pciada->pvVirtLcr + 0x4C);
		844	pciada->pwCntrl = (PUSHORT)((PUCHAR)pciada->pvVirtLcr + 0x50);
		845	}
		846
		847	return STATUS_SUCCESS;
		848	}
		849
		850
		851	//------------------------------------------------------------------------
		852	// initializes and registers a DPC routine for each pciada
		853	//
		854	NTSTATUS InitializeCustomDPCObjects(PDEVICE_OBJECT device_object)
		855	{
		856	int i;
		857	DEVICE_EXT pDevExt = (DEVICE_EXT)(device_object->DeviceExtension);
		858	int nPCIADAs = pDevExt->nPCIADAs;
		859	PCIADA *pciada;
		860
		861	KdPrint(("InitializeCustomDPCObject()\n"));
		862
		863	for (i = 0; i < nPCIADAs; i++)
		864	{
		865	pciada = &pDevExt->pciada[i];
		866	KeInitializeDpc(&pciada->kDPCobj, fMyDefferedRoutine, (PVOID)device_object);
		867	}
		868
		869	return STATUS_SUCCESS;
		870	}
		871
		872	//------------------------------------------------------------------------
		873	// init structures a.s.o.
		874	//
		875	VOID PCICC32SoftInit(PDEVICE_OBJECT device_Obj)
		876	{
		877	int i;
		878	PCIADA *pciada;
		879
		880	for (i = 0; i < PCICC32_MAX_PCIADA; i++)
		881	{
		882	pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
		883
		884	pciada->pvPhysLcr.QuadPart = pciada->pvPhysIfr.QuadPart = 0;
		885	pciada->pvVirtLcr = pciada->pvVirtIfr = NULL;
		886
		887	pciada->bConnected = FALSE; // connection still not verified
		888	pciada->wModuleNumber = 0xFFFF;
		889	pciada->wFPGAVersion = 0xFFFF;
		890	pciada->wModuleType = 1; // always CC32
		891
		892	pciada->InterruptObject = NULL;
		893	pciada->Irql = 0;
		894	pciada->Vector = 0;
		895	pciada->Affinity = 0;
		896
		897	pciada->dwLinkCount = 0;
		898
		899	pciada->dwIrqStatus = 0;
		900	pciada->pBlockingIrp = (PIRP *)NULL;
		901
		902	pciada->pIrqControlFile = (FILE_OBJ *)NULL;
		903	}
		904
		905	// no CC32 associated to any PCIADA
		906	for (i = 0; i < PCICC32_MAX_CC32; i++)
		907	((DEVICE_EXT*)(device_Obj->DeviceExtension))->cc32[i] = NULL;
		908	}
		909
		910	//------------------------------------------------------------------------
		911	// the ultimate starting point of a driver
		912	NTSTATUS DriverEntry(PDRIVER_OBJECT driverObj, PUNICODE_STRING regPath)
		913	{
		914	int i;
		915	PDEVICE_OBJECT device_object; // pointer to the device object
		916	UNICODE_STRING device_name;
		917	UNICODE_STRING symbol_name;
		918	NTSTATUS result = STATUS_SUCCESS;
		919	PCIADA *pciada; // pointer to a PCIADA
		920	int nPCIADAs; // count of PCIADAs
		921	DEVICE_EXT *DeviceExtension = NULL;
		922
		923	KdPrint(("DriverEntry() ----%d.%d-------------------------\n", (DRIVER_VERSION >> 16) & 0xFFFF, DRIVER_VERSION & 0xFFFF));
		924
		925	driverObj->DriverUnload = PCICC32Unload;
		926	driverObj->MajorFunction[IRP_MJ_CREATE] = PCICC32Open;
		927	driverObj->MajorFunction[IRP_MJ_CLOSE] = PCICC32Close;
		928	driverObj->MajorFunction[IRP_MJ_READ] = PCICC32Read;
		929	driverObj->MajorFunction[IRP_MJ_WRITE] = PCICC32Write;
		930	driverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PCICC32DeviceControl;
		931	driverObj->MajorFunction[IRP_MJ_SHUTDOWN] = PCICC32Shutdown;
		932
		933	RtlInitUnicodeString(&device_name, L"\\Device\\CC32");
		934
		935	/* DeviceObject durch IO-Manager erzeugen */
		936	result = IoCreateDevice( driverObj, // DriverObject received by the DriverEntry Call
		937	sizeof(DEVICE_EXT), // required Memory for the DeviceExtension
		938	&device_name, // Name of the device in the device-Directory
		939	FILE_DEVICE_UNKNOWN, // Device-ID
		940	0, // Device-Characteristics normal 0
		941	FALSE, // TRUE : one Thread can open the driver
		942	&device_object); // DeviceObject returned from the IO-Manager
		943
		944	// defines how the data are handled between user / kernel Adress-Space
		945	device_object->Flags \|= DO_DIRECT_IO;
		946
		947	// anounce driver as symbolic device ---------------------------------
		948	if (result == STATUS_SUCCESS)
		949	{
		950	/* now the symbolic Link is created. If there is no S.L. a program cannot connect to the driver */
		951	RtlInitUnicodeString(&symbol_name, DOS_DEVICE_NAME);
		952	result = IoCreateSymbolicLink(&symbol_name,&device_name);
		953	if (result != STATUS_SUCCESS)
		954	{
		955	IoDeleteDevice(device_object);
		956	return result;
		957	}
		958	}
		959	else
		960	return result;
		961
		962	DeviceExtension = (DEVICE_EXT*)device_object->DeviceExtension;
		963
		964	DeviceExtension->actualIrp = NULL;
		965	DeviceExtension->nInitState = 0;
		966
		967	// init pciada structures ------------------------------------
		968	PCICC32SoftInit(device_object);
		969
		970	// search for PCIADAs ----------------------------------------
		971	result = SearchDevices(device_object);
		972	nPCIADAs = DeviceExtension->nPCIADAs;
		973
		974	if ((result != STATUS_SUCCESS) \|\| !(nPCIADAs))
		975	{
		976	PCICC32Unload(driverObj);
		977	return STATUS_DEVICE_DOES_NOT_EXIST;
		978	}
		979
		980	// request exclusive ownership of .. ---------------------------------
		981	if ((result = PCICC32ReserveResources(device_object)) != STATUS_SUCCESS)
		982	{
		983	PCICC32Unload(driverObj);
		984	return result;
		985	}
		986	else
		987	DeviceExtension->nInitState++;
		988
		989	// fix PLX9050 Bug -------------------------------------------
		990	if ((result = PLX9050BugFix(device_object)) != STATUS_SUCCESS)
		991	{
		992	PCICC32Unload(driverObj);
		993	return result;
		994	}
		995
		996	// translate BUS relative addresses ----------------------------------
		997	if ((result = PCICC32TranslateBusAddresses(device_object)) != STATUS_SUCCESS)
		998	{
		999	PCICC32Unload(driverObj);
		1000	return STATUS_DEVICE_DOES_NOT_EXIST;
		1001	}
		1002	else
		1003	DeviceExtension->nInitState++;
		1004
		1005	// translate Interrupt Resources used --------------------------------
		1006	if ((result = PCICC32TranslateInterrupt(device_object)) != STATUS_SUCCESS)
		1007	{
		1008	PCICC32Unload(driverObj);
		1009	return STATUS_DEVICE_DOES_NOT_EXIST;
		1010	}
		1011	else
		1012	DeviceExtension->nInitState++;
		1013
		1014	// map address spaces to virtual addresses ---------------------------
		1015	if ((result = PCICC32MapIOspaces(device_object)) != STATUS_SUCCESS)
		1016	{
		1017	PCICC32Unload(driverObj);
		1018	return STATUS_DEVICE_DOES_NOT_EXIST;
		1019	}
		1020	else
		1021	DeviceExtension->nInitState++;
		1022
		1023	// initialze my custom DPC objects -----------------------------------
		1024	if ((result = InitializeCustomDPCObjects(device_object)) != STATUS_SUCCESS)
		1025	{
		1026	PCICC32Unload(driverObj);
		1027	return result;
		1028	}
		1029	else
		1030	DeviceExtension->nInitState++;
		1031
		1032	// disable all interrupts --------------------------------------------
		1033	for (i = 0; i < nPCIADAs; i++)
		1034	{
		1035	pciada = &DeviceExtension->pciada[i];
		1036
		1037	globalInterruptDisable(pciada);
		1038	}
		1039
		1040	// connect interrupts to service routines ----------------------------
		1041	if ((result = PCICC32ConnectInterrupt(device_object)) != STATUS_SUCCESS)
		1042	{
		1043	PCICC32Unload(driverObj);
		1044	return STATUS_DEVICE_DOES_NOT_EXIST;
		1045	}
		1046	else
		1047	DeviceExtension->nInitState++;
		1048
		1049	// scan all connected CC32 for info and later use -------------------
		1050	if ((result = PCICC32ScanCC32(device_object)) != STATUS_SUCCESS)
		1051	{
		1052	PCICC32Unload(driverObj);
		1053	return STATUS_DEVICE_DOES_NOT_EXIST;
		1054	}
		1055
		1056	device_object->Flags &= ~DO_DEVICE_INITIALIZING;
		1057
		1058	KdPrint(("DriverEntry() OK.\n"));
		1059
		1060	return result;
		1061	}
		1062

Subversion Repositories f9daq

(root)/wiener_pcicc32/SOURCE/pcicc32_drv.c - Rev 23