//------------------------------------------------------------------------------
NTSTATUS DriverEntry(PDRIVER_OBJECT driverObject_p,
PUNICODE_STRING registryPath_p)
{
NDIS_STATUS ndisStatus = NDIS_STATUS_SUCCESS;
DEBUG_LVL_ALWAYS_TRACE("PLK: + %s()\n", __func__);
ndisStatus = ndis_initDriver(driverObject_p, registryPath_p);
if (ndisStatus != NDIS_STATUS_SUCCESS)
{
DEBUG_LVL_ERROR_TRACE("%s() Failed to initialize driver 0x%X\n",
__func__,
ndisStatus);
return ndisStatus;
}
// register driver interface handlers
ndis_registerDrvIntf(registerDrvIntf, deregisterDrvIntf);
plkDriverInstance_l.fInitialized = FALSE;
plkDriverInstance_l.instanceCount = 0;
DEBUG_LVL_ALWAYS_TRACE("PLK: + %s() - OK\n", __func__);
return ndisStatus;
}
//------------------------------------------------------------------------------
tOplkError drv_init(void)
{
tOplkError ret = kErrorOk;
DEBUG_LVL_ALWAYS_TRACE("Initialize driver interface...");
DEBUG_LVL_ALWAYS_TRACE(" OK\n");
return ret;
}
//------------------------------------------------------------------------------
static void registerDrvIntf(NDIS_HANDLE driverHandle_p)
{
NDIS_STATUS status = NDIS_STATUS_SUCCESS;
UNICODE_STRING deviceName;
UNICODE_STRING deviceLinkUnicodeString;
NDIS_DEVICE_OBJECT_ATTRIBUTES deviceObjectAttributes;
PDRIVER_DISPATCH dispatchTable[IRP_MJ_MAXIMUM_FUNCTION + 1];
DEBUG_LVL_ALWAYS_TRACE("PLK %s()...\n", __func__);
plkDriverInstance_l.driverHandle = driverHandle_p;
NdisZeroMemory(dispatchTable, (IRP_MJ_MAXIMUM_FUNCTION + 1) * sizeof(PDRIVER_DISPATCH));
dispatchTable[IRP_MJ_CREATE] = powerlinkCreate;
dispatchTable[IRP_MJ_CLEANUP] = powerlinkCleanup;
dispatchTable[IRP_MJ_CLOSE] = powerlinkClose;
dispatchTable[IRP_MJ_DEVICE_CONTROL] = powerlinkIoctl;
NdisInitUnicodeString(&deviceName, PLK_DEV_STRING);
NdisInitUnicodeString(&deviceLinkUnicodeString, PLK_LINK_NAME);
NdisZeroMemory(&deviceObjectAttributes, sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES));
// type implicit from the context
deviceObjectAttributes.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
deviceObjectAttributes.Header.Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
deviceObjectAttributes.Header.Size = sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES);
deviceObjectAttributes.DeviceName = &deviceName;
deviceObjectAttributes.SymbolicName = &deviceLinkUnicodeString;
deviceObjectAttributes.MajorFunctions = &dispatchTable[0];
deviceObjectAttributes.ExtensionSize = 0;
deviceObjectAttributes.DefaultSDDLString = NULL;
deviceObjectAttributes.DeviceClassGuid = 0;
status = NdisRegisterDeviceEx(driverHandle_p,
&deviceObjectAttributes,
&plkDriverInstance_l.pDrvDeviceObject,
&plkDriverInstance_l.pDrvDeviceHandle);
if (status != NDIS_STATUS_SUCCESS)
{
DEBUG_LVL_ERROR_TRACE("%s() Failed to register interface device (0x%X)\n", status);
return;
}
plkDriverInstance_l.pDrvDeviceObject->Flags |= DO_BUFFERED_IO;
DEBUG_LVL_ALWAYS_TRACE("PLK %s() - OK\n", __func__);
}
//------------------------------------------------------------------------------
NTSTATUS powerlinkClose(PDEVICE_OBJECT pDeviceObject_p,
PIRP pIrp_p)
{
tFileContext* pFileContext;
PIO_STACK_LOCATION irpStack;
UINT16 status;
tCtrlCmd ctrlCmd;
UNUSED_PARAMETER(pDeviceObject_p);
DEBUG_LVL_ALWAYS_TRACE("PLK: + %s()...\n", __func__);
if (pIrp_p == NULL)
return NDIS_STATUS_RESOURCES;
irpStack = IoGetCurrentIrpStackLocation(pIrp_p);
pFileContext = irpStack->FileObject->FsContext;
ExFreePoolWithTag(pFileContext, PLK_MEM_TAG);
plkDriverInstance_l.instanceCount--;
// Close lower driver resources only if all open instances have closed.
if (plkDriverInstance_l.fInitialized &&
(plkDriverInstance_l.instanceCount == 0))
{
plkDriverInstance_l.fInitialized = FALSE;
stopHeartbeatTimer();
ctrlk_exit();
drv_getStatus(&status);
if (status == kCtrlStatusRunning)
{
ctrlCmd.cmd = kCtrlShutdown;
drv_executeCmd(&ctrlCmd);
}
}
pIrp_p->IoStatus.Information = 0;
pIrp_p->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp_p, IO_NO_INCREMENT);
DEBUG_LVL_ALWAYS_TRACE("PLK: + %s() - OK\n", __func__);
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------------
tOplkError zynqdrv_init(void)
{
tOplkError ret = kErrorOk;
INT result;
// Clear instance structure
OPLK_MEMSET(&instance_l, 0, sizeof(instance_l));
DEBUG_LVL_ALWAYS_TRACE("%s(): Registering the driver to the kernel...",
__func__);
/*
* TODO: This function can be replaced with platform_driver_probe
* to reduce memory footprints
*/
result = platform_driver_register(&pcpDriver_l);
if (result != 0)
return kErrorNoResource;
DEBUG_LVL_ALWAYS_TRACE("Done\n");
return ret;
}
//------------------------------------------------------------------------------
NTSTATUS powerlinkCreate(PDEVICE_OBJECT pDeviceObject_p,
PIRP pIrp_p)
{
NDIS_TIMER_CHARACTERISTICS timerChars;
tFileContext* pFileContext;
PIO_STACK_LOCATION irpStack;
NDIS_STATUS status;
UNUSED_PARAMETER(pDeviceObject_p);
DEBUG_LVL_ALWAYS_TRACE("PLK: + %s() ...\n", __func__);
if (pIrp_p == NULL)
return NDIS_STATUS_RESOURCES;
irpStack = IoGetCurrentIrpStackLocation(pIrp_p);
pFileContext = ExAllocatePoolWithQuotaTag(NonPagedPool,
sizeof(tFileContext),
PLK_MEM_TAG);
if (pFileContext == NULL)
{
DEBUG_LVL_ERROR_TRACE("PLK: Failed to create file context\n");
}
IoInitializeRemoveLock(&pFileContext->driverAccessLock, PLK_MEM_TAG, 0, 0);
irpStack->FileObject->FsContext = (void*)pFileContext;
if (!plkDriverInstance_l.fInitialized)
{
NdisZeroMemory(&timerChars, sizeof(timerChars));
C_ASSERT(NDIS_SIZEOF_TIMER_CHARACTERISTICS_REVISION_1 <= sizeof(timerChars));
timerChars.Header.Type = NDIS_OBJECT_TYPE_TIMER_CHARACTERISTICS;
timerChars.Header.Size = NDIS_SIZEOF_TIMER_CHARACTERISTICS_REVISION_1;
timerChars.Header.Revision = NDIS_TIMER_CHARACTERISTICS_REVISION_1;
timerChars.TimerFunction = increaseHeartbeatCb;
timerChars.FunctionContext = NULL;
timerChars.AllocationTag = PLK_MEM_TAG;
status = NdisAllocateTimerObject(plkDriverInstance_l.driverHandle,
&timerChars,
&heartbeatTimer_l);
if (status != NDIS_STATUS_SUCCESS)
{
DEBUG_LVL_ERROR_TRACE("%s() Timer Creation Failed %x\n", __func__, status);
return STATUS_SUCCESS;
}
if (ctrlk_init(NULL) != kErrorOk)
{
return NDIS_STATUS_RESOURCES;
}
startHeartbeatTimer(20);
plkDriverInstance_l.fInitialized = TRUE;
}
// Increase the count for open instances
plkDriverInstance_l.instanceCount++;
pIrp_p->IoStatus.Information = 0;
pIrp_p->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp_p, IO_NO_INCREMENT);
DEBUG_LVL_ALWAYS_TRACE("PLK: + %s() - OK\n", __func__);
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------------
tOplkError drv_mapPdoMem(void** ppKernelMem_p,
void** ppUserMem_p,
size_t* pMemSize_p)
{
tOplkError ret;
// Get PDO memory
ret = pdokcal_getPdoMemRegion(&pdoMemInfo_l.pKernelVa,
&pdoMemInfo_l.memSize);
if ((ret != kErrorOk) ||
(pdoMemInfo_l.pKernelVa == NULL))
return kErrorNoResource;
if (*pMemSize_p > pdoMemInfo_l.memSize)
{
DEBUG_LVL_ERROR_TRACE("%s() Higher memory requested (Kernel-%d User-%d) !\n",
__func__,
pdoMemInfo_l.memSize,
*pMemSize_p);
*pMemSize_p = 0;
return kErrorNoResource;
}
// Allocate new MDL pointing to PDO memory
pdoMemInfo_l.pMdl = IoAllocateMdl(pdoMemInfo_l.pKernelVa,
pdoMemInfo_l.memSize,
FALSE,
FALSE,
NULL);
if (pdoMemInfo_l.pMdl == NULL)
{
DEBUG_LVL_ERROR_TRACE("%s() Error allocating MDL !\n", __func__);
return kErrorNoResource;
}
// Update the MDL with physical addresses
MmBuildMdlForNonPagedPool(pdoMemInfo_l.pMdl);
// Map the memory in user space and get the address
pdoMemInfo_l.pUserVa = MmMapLockedPagesSpecifyCache(pdoMemInfo_l.pMdl, // MDL
UserMode, // Mode
MmCached, // Caching
NULL, // Address
FALSE, // Bug-check?
NormalPagePriority); // Priority
if (pdoMemInfo_l.pUserVa == NULL)
{
MmUnmapLockedPages(pdoMemInfo_l.pUserVa, pdoMemInfo_l.pMdl);
IoFreeMdl(pdoMemInfo_l.pMdl);
DEBUG_LVL_ERROR_TRACE("%s() Error mapping MDL !\n", __func__);
return kErrorNoResource;
}
*ppKernelMem_p = pdoMemInfo_l.pKernelVa;
*ppUserMem_p = pdoMemInfo_l.pUserVa;
*pMemSize_p = pdoMemInfo_l.memSize;
DEBUG_LVL_ALWAYS_TRACE("Mapped memory info U:%p K:%p size %x",
pdoMemInfo_l.pUserVa,
pdoMemInfo_l.pKernelVa,
pdoMemInfo_l.memSize);
return kErrorOk;
}
//------------------------------------------------------------------------------
void drv_exit(void)
{
DEBUG_LVL_ALWAYS_TRACE("Exit driver interface...\n");
}
//------------------------------------------------------------------------------
tOplkError drv_mapSocMem(void** ppUserMem_p,
size_t* pMemSize_p)
{
if ((ppUserMem_p == NULL) || (pMemSize_p == NULL))
{
DEBUG_LVL_ERROR_TRACE("%s() Invalid pointer !\n", __func__);
return kErrorNoResource;
}
// Get SoC memory
socMemInfo_l.pKernelVa = timesynckcal_getSharedMemory();
if (socMemInfo_l.pKernelVa == NULL)
{
DEBUG_LVL_ERROR_TRACE("%s() Timesync shared memory is NULL !", __func__);
return kErrorNoResource;
}
// Set SoC memory size
socMemInfo_l.memSize = sizeof(tTimesyncSharedMemory);
if (*pMemSize_p > socMemInfo_l.memSize)
{
DEBUG_LVL_ERROR_TRACE("%s() Higher memory requested (Kernel:%uz User:%uz) !\n",
__func__,
socMemInfo_l.memSize,
*pMemSize_p);
*pMemSize_p = 0;
return kErrorNoResource;
}
// Allocate new MDL pointing to SoC memory
socMemInfo_l.pMdl = IoAllocateMdl(socMemInfo_l.pKernelVa,
socMemInfo_l.memSize,
FALSE,
FALSE,
NULL);
if (socMemInfo_l.pMdl == NULL)
{
DEBUG_LVL_ERROR_TRACE("%s() Error allocating MDL !\n", __func__);
return kErrorNoResource;
}
// Update the MDL with physical addresses
MmBuildMdlForNonPagedPool(socMemInfo_l.pMdl);
// Maps the physical pages that are described by an MDL to a virtual address
socMemInfo_l.pUserVa = MmMapLockedPagesSpecifyCache(socMemInfo_l.pMdl, // MDL
UserMode, // Mode
MmCached, // Caching
NULL, // Address
FALSE, // Bug-check?
NormalPagePriority); // Priority
if (socMemInfo_l.pUserVa == NULL)
{
MmUnmapLockedPages(socMemInfo_l.pUserVa, socMemInfo_l.pMdl);
IoFreeMdl(socMemInfo_l.pMdl);
DEBUG_LVL_ERROR_TRACE("%s() Error mapping MDL !\n", __func__);
return kErrorNoResource;
}
*ppUserMem_p = socMemInfo_l.pUserVa;
*pMemSize_p = socMemInfo_l.memSize;
DEBUG_LVL_ALWAYS_TRACE("Mapped SoC memory info U:%p K:%p size:%uz\n",
socMemInfo_l.pUserVa,
socMemInfo_l.pKernelVa,
socMemInfo_l.memSize);
return kErrorOk;
}
