gceSTATUS
gckIOMMU_Construct(
IN gckOS Os,
OUT gckIOMMU * Iommu
)
{
gceSTATUS status;
gckIOMMU iommu = gcvNULL;
struct device *dev;
int ret;
gcmkHEADER();
dev = &Os->device->platform->device->dev;
gcmkONERROR(gckOS_Allocate(Os, gcmSIZEOF(gcsIOMMU), (gctPOINTER *)&iommu));
gckOS_ZeroMemory(iommu, gcmSIZEOF(gcsIOMMU));
iommu->domain = iommu_domain_alloc(&platform_bus_type);
if (!iommu->domain)
{
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_OS, "iommu_domain_alloc() fail");
gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
}
iommu_set_fault_handler(iommu->domain, _IOMMU_Fault_Handler, dev);
ret = iommu_attach_device(iommu->domain, dev);
if (ret)
{
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_OS, "iommu_attach_device() fail %d", ret);
gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
}
iommu->device = dev;
_FlatMapping(iommu);
*Iommu = iommu;
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gckIOMMU_Destory(Os, iommu);
gcmkFOOTER();
return status;
}
/*******************************************************************************
**
** _Split
**
** Split a node on the required byte boundary.
**
** INPUT:
**
** gckOS Os
** Pointer to an gckOS object.
**
** gcuVIDMEM_NODE_PTR Node
** Pointer to the node to split.
**
** gctSIZE_T Bytes
** Number of bytes to keep in the node.
**
** OUTPUT:
**
** Nothing.
**
** RETURNS:
**
** gctBOOL
** gcvTRUE if the node was split successfully, or gcvFALSE if there is an
** error.
**
*/
static gctBOOL
_Split(
IN gckOS Os,
IN gcuVIDMEM_NODE_PTR Node,
IN gctSIZE_T Bytes
)
{
gcuVIDMEM_NODE_PTR node;
/* Make sure the byte boundary makes sense. */
if ((Bytes <= 0) || (Bytes > Node->VidMem.bytes))
{
return gcvFALSE;
}
/* Allocate a new gcuVIDMEM_NODE object. */
if (gcmIS_ERROR(gckOS_Allocate(Os,
gcmSIZEOF(gcuVIDMEM_NODE),
(gctPOINTER *) &node)))
{
/* Error. */
return gcvFALSE;
}
/* Initialize gcuVIDMEM_NODE structure. */
node->VidMem.offset = Node->VidMem.offset + Bytes;
node->VidMem.bytes = Node->VidMem.bytes - Bytes;
node->VidMem.alignment = 0;
node->VidMem.locked = 0;
node->VidMem.memory = Node->VidMem.memory;
node->VidMem.pool = Node->VidMem.pool;
node->VidMem.physical = Node->VidMem.physical;
#ifdef __QNXNTO__
node->VidMem.logical = gcvNULL;
node->VidMem.handle = 0;
#endif
/* Insert node behind specified node. */
node->VidMem.next = Node->VidMem.next;
node->VidMem.prev = Node;
Node->VidMem.next = node->VidMem.next->VidMem.prev = node;
/* Insert free node behind specified node. */
node->VidMem.nextFree = Node->VidMem.nextFree;
node->VidMem.prevFree = Node;
Node->VidMem.nextFree = node->VidMem.nextFree->VidMem.prevFree = node;
/* Adjust size of specified node. */
Node->VidMem.bytes = Bytes;
/* Success. */
return gcvTRUE;
}
static gceSTATUS
_AddMap(
IN gckOS Os,
IN gctPOINTER Source,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Destination,
IN OUT gcsMAPPED_PTR * Stack
)
{
gcsMAPPED_PTR map = gcvNULL;
gceSTATUS status;
/* Don't try to map NULL pointers. */
if (Source == gcvNULL)
{
*Destination = gcvNULL;
return gcvSTATUS_OK;
}
/* Allocate the gcsMAPPED structure. */
gcmkONERROR(
gckOS_Allocate(Os, gcmSIZEOF(*map), (gctPOINTER *) &map));
/* Map the user pointer into kernel addressing space. */
gcmkONERROR(
gckOS_MapUserPointer(Os, Source, Bytes, Destination));
/* Save mapping. */
map->pointer = Source;
map->kernelPointer = *Destination;
map->bytes = Bytes;
/* Push structure on top of the stack. */
map->next = *Stack;
*Stack = map;
/* Success. */
return gcvSTATUS_OK;
OnError:
if (gcmIS_ERROR(status) && (map != gcvNULL))
{
/* Roll back on error. */
gcmkVERIFY_OK(gckOS_Free(Os, map));
}
/* Return the status. */
return status;
}
/*******************************************************************************
**
** gckVGMMU_Construct
**
** Construct a new gckVGMMU object.
**
** INPUT:
**
** gckVGKERNEL Kernel
** Pointer to an gckVGKERNEL object.
**
** gctSIZE_T MmuSize
** Number of bytes for the page table.
**
** OUTPUT:
**
** gckVGMMU * Mmu
** Pointer to a variable that receives the gckVGMMU object pointer.
*/
gceSTATUS gckVGMMU_Construct(
IN gckVGKERNEL Kernel,
IN gctSIZE_T MmuSize,
OUT gckVGMMU * Mmu
)
{
gckOS os;
gckVGHARDWARE hardware;
gceSTATUS status;
gckVGMMU mmu;
gctUINT32 * pageTable;
gctUINT32 i;
gcmkHEADER_ARG("Kernel=0x%x MmuSize=0x%x Mmu=0x%x", Kernel, MmuSize, Mmu);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
gcmkVERIFY_ARGUMENT(MmuSize > 0);
gcmkVERIFY_ARGUMENT(Mmu != gcvNULL);
/* Extract the gckOS object pointer. */
os = Kernel->os;
gcmkVERIFY_OBJECT(os, gcvOBJ_OS);
/* Extract the gckVGHARDWARE object pointer. */
hardware = Kernel->hardware;
gcmkVERIFY_OBJECT(hardware, gcvOBJ_HARDWARE);
/* Allocate memory for the gckVGMMU object. */
status = gckOS_Allocate(os, sizeof(struct _gckVGMMU), (gctPOINTER *) &mmu);
if (status < 0)
{
/* Error. */
gcmkFATAL(
"%s(%d): could not allocate gckVGMMU object.",
__FUNCTION__, __LINE__
);
gcmkFOOTER();
return status;
}
/* Initialize the gckVGMMU object. */
mmu->object.type = gcvOBJ_MMU;
mmu->os = os;
mmu->hardware = hardware;
/* Create the mutex. */
status = gckOS_CreateMutex(os, &mmu->mutex);
if (status < 0)
{
/* Roll back. */
mmu->object.type = gcvOBJ_UNKNOWN;
gcmkVERIFY_OK(gckOS_Free(os, mmu));
gcmkFOOTER();
/* Error. */
return status;
}
/* Allocate the page table. */
mmu->pageTableSize = MmuSize;
status = gckOS_AllocateContiguous(os,
gcvFALSE,
&mmu->pageTableSize,
&mmu->pageTablePhysical,
&mmu->pageTableLogical);
if (status < 0)
{
/* Roll back. */
gcmkVERIFY_OK(gckOS_DeleteMutex(os, mmu->mutex));
mmu->object.type = gcvOBJ_UNKNOWN;
gcmkVERIFY_OK(gckOS_Free(os, mmu));
/* Error. */
gcmkFATAL(
"%s(%d): could not allocate page table.",
__FUNCTION__, __LINE__
);
gcmkFOOTER();
return status;
}
/* Compute number of entries in page table. */
mmu->entryCount = mmu->pageTableSize / sizeof(gctUINT32);
mmu->entry = 0;
/* Mark the entire page table as available. */
pageTable = (gctUINT32 *) mmu->pageTableLogical;
for (i = 0; i < mmu->entryCount; i++)
{
pageTable[i] = (gctUINT32)~0;
}
/* Set page table address. */
status = gckVGHARDWARE_SetMMU(hardware, mmu->pageTableLogical);
if (status < 0)
{
/* Free the page table. */
gcmkVERIFY_OK(gckOS_FreeContiguous(mmu->os,
mmu->pageTablePhysical,
mmu->pageTableLogical,
mmu->pageTableSize));
/* Roll back. */
gcmkVERIFY_OK(gckOS_DeleteMutex(os, mmu->mutex));
mmu->object.type = gcvOBJ_UNKNOWN;
gcmkVERIFY_OK(gckOS_Free(os, mmu));
/* Error. */
gcmkFATAL(
"%s(%d): could not program page table.",
__FUNCTION__, __LINE__
);
gcmkFOOTER();
return status;
}
/* Return the gckVGMMU object pointer. */
*Mmu = mmu;
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_MMU,
"%s(%d): %u entries at %p.(0x%08X)\n",
__FUNCTION__, __LINE__,
mmu->entryCount,
mmu->pageTableLogical,
mmu->pageTablePhysical
);
gcmkFOOTER_NO();
/* Success. */
return gcvSTATUS_OK;
}
/*******************************************************************************
**
** gckVIDMEM_ConstructVirtual
**
** Construct a new gcuVIDMEM_NODE union for virtual memory.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to an gckKERNEL object.
**
** gctSIZE_T Bytes
** Number of byte to allocate.
**
** OUTPUT:
**
** gcuVIDMEM_NODE_PTR * Node
** Pointer to a variable that receives the gcuVIDMEM_NODE union pointer.
*/
gceSTATUS
gckVIDMEM_ConstructVirtual(
IN gckKERNEL Kernel,
IN gctBOOL Contiguous,
IN gctSIZE_T Bytes,
#ifdef __QNXNTO__
IN gctHANDLE Handle,
#endif
OUT gcuVIDMEM_NODE_PTR * Node
)
{
gckOS os;
gceSTATUS status;
gcuVIDMEM_NODE_PTR node = gcvNULL;
gcmkHEADER_ARG("Kernel=0x%x Bytes=%lu", Kernel, Bytes);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Kernel, gcvOBJ_KERNEL);
gcmkVERIFY_ARGUMENT(Bytes > 0);
gcmkVERIFY_ARGUMENT(Node != gcvNULL);
#ifdef __QNXNTO__
gcmkVERIFY_ARGUMENT(Handle != gcvNULL);
#endif
/* Extract the gckOS object pointer. */
os = Kernel->os;
gcmkVERIFY_OBJECT(os, gcvOBJ_OS);
/* Allocate an gcuVIDMEM_NODE union. */
gcmkONERROR(
gckOS_Allocate(os, gcmSIZEOF(gcuVIDMEM_NODE), (gctPOINTER *) &node));
/* Initialize gcuVIDMEM_NODE union for virtual memory. */
node->Virtual.kernel = Kernel;
node->Virtual.contiguous = Contiguous;
node->Virtual.locked = 0;
node->Virtual.logical = gcvNULL;
node->Virtual.pageTable = gcvNULL;
node->Virtual.mutex = gcvNULL;
#ifdef __QNXNTO__
node->Virtual.next = gcvNULL;
node->Virtual.unlockPending = gcvFALSE;
node->Virtual.freePending = gcvFALSE;
node->Virtual.handle = Handle;
#else
node->Virtual.pending = gcvFALSE;
#endif
/* Create the mutex. */
gcmkONERROR(
gckOS_CreateMutex(os, &node->Virtual.mutex));
/* Allocate the virtual memory. */
gcmkONERROR(
gckOS_AllocatePagedMemoryEx(os,
node->Virtual.contiguous,
node->Virtual.bytes = Bytes,
&node->Virtual.physical));
#ifdef __QNXNTO__
/* Register. */
gckMMU_InsertNode(Kernel->mmu, node);
#endif
/* Return pointer to the gcuVIDMEM_NODE union. */
*Node = node;
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_VIDMEM,
"Created virtual node 0x%x for %u bytes @ 0x%x",
node, Bytes, node->Virtual.physical);
/* Success. */
gcmkFOOTER_ARG("*Node=0x%x", *Node);
return gcvSTATUS_OK;
OnError:
/* Roll back. */
if (node != gcvNULL)
{
if (node->Virtual.mutex != gcvNULL)
{
/* Destroy the mutex. */
gcmkVERIFY_OK(gckOS_DeleteMutex(os, node->Virtual.mutex));
}
/* Free the structure. */
gcmkVERIFY_OK(gckOS_Free(os, node));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
**
** gckKERNEL_Construct
**
** Construct a new gckKERNEL object.
**
** INPUT:
**
** gckOS Os
** Pointer to an gckOS object.
**
** IN gctPOINTER Context
** Pointer to a driver defined context.
**
** OUTPUT:
**
** gckKERNEL * Kernel
** Pointer to a variable that will hold the pointer to the gckKERNEL
** object.
*/
gceSTATUS gckVGKERNEL_Construct(
IN gckOS Os,
IN gctPOINTER Context,
IN gckKERNEL inKernel,
OUT gckVGKERNEL * Kernel
)
{
gceSTATUS status;
gckVGKERNEL kernel = gcvNULL;
gcmkHEADER_ARG("Os=0x%x Context=0x%x", Os, Context);
/* Verify the arguments. */
gcmkVERIFY_OBJECT(Os, gcvOBJ_OS);
gcmkVERIFY_ARGUMENT(Kernel != gcvNULL);
do
{
/* Allocate the gckKERNEL object. */
gcmkERR_BREAK(gckOS_Allocate(
Os,
sizeof(struct _gckVGKERNEL),
(gctPOINTER *) &kernel
));
/* Initialize the gckKERNEL object. */
kernel->object.type = gcvOBJ_KERNEL;
kernel->os = Os;
kernel->context = Context;
kernel->hardware = gcvNULL;
kernel->interrupt = gcvNULL;
kernel->command = gcvNULL;
kernel->mmu = gcvNULL;
kernel->kernel = inKernel;
/* Construct the gckVGHARDWARE object. */
gcmkERR_BREAK(gckVGHARDWARE_Construct(
Os, &kernel->hardware
));
/* Set pointer to gckKERNEL object in gckVGHARDWARE object. */
kernel->hardware->kernel = kernel;
/* Construct the gckVGINTERRUPT object. */
gcmkERR_BREAK(gckVGINTERRUPT_Construct(
kernel, &kernel->interrupt
));
/* Construct the gckVGCOMMAND object. */
gcmkERR_BREAK(gckVGCOMMAND_Construct(
kernel, gcmKB2BYTES(8), gcmKB2BYTES(2), &kernel->command
));
/* Construct the gckVGMMU object. */
gcmkERR_BREAK(gckVGMMU_Construct(
kernel, gcmKB2BYTES(32), &kernel->mmu
));
/* Return pointer to the gckKERNEL object. */
*Kernel = kernel;
gcmkFOOTER_ARG("*Kernel=0x%x", *Kernel);
/* Success. */
return gcvSTATUS_OK;
}
while (gcvFALSE);
/* Roll back. */
if (kernel != gcvNULL)
{
if (kernel->mmu != gcvNULL)
{
gcmkVERIFY_OK(gckVGMMU_Destroy(kernel->mmu));
}
if (kernel->command != gcvNULL)
{
gcmkVERIFY_OK(gckVGCOMMAND_Destroy(kernel->command));
}
if (kernel->interrupt != gcvNULL)
{
gcmkVERIFY_OK(gckVGINTERRUPT_Destroy(kernel->interrupt));
}
if (kernel->hardware != gcvNULL)
{
gcmkVERIFY_OK(gckVGHARDWARE_Destroy(kernel->hardware));
}
gcmkVERIFY_OK(gckOS_Free(Os, kernel));
}
gcmkFOOTER();
/* Return status. */
return status;
}
/*******************************************************************************
** gckKERNEL_NewDatabase
**
** Create a new database structure and insert it to the head of the hash list.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** gctUINT32 ProcessID
** ProcessID that identifies the database.
**
** OUTPUT:
**
** gcsDATABASE_PTR * Database
** Pointer to a variable receiving the database structure pointer on
** success.
*/
static gceSTATUS
gckKERNEL_NewDatabase(
IN gckKERNEL Kernel,
IN gctUINT32 ProcessID,
OUT gcsDATABASE_PTR * Database
)
{
gceSTATUS status;
gcsDATABASE_PTR database;
gctBOOL acquired = gcvFALSE;
gctSIZE_T slot;
gcsDATABASE_PTR existingDatabase;
gcmkHEADER_ARG("Kernel=0x%x ProcessID=%d", Kernel, ProcessID);
/* Acquire the database mutex. */
gcmkONERROR(gckOS_AcquireMutex(Kernel->os, Kernel->db->dbMutex, gcvINFINITE));
acquired = gcvTRUE;
/* Compute the hash for the database. */
slot = ProcessID % gcmCOUNTOF(Kernel->db->db);
/* Walk the hash list. */
for (existingDatabase = Kernel->db->db[slot];
existingDatabase != gcvNULL;
existingDatabase = existingDatabase->next)
{
if (existingDatabase->processID == ProcessID)
{
/* One process can't be added twice. */
gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
}
}
if (Kernel->db->freeDatabase != gcvNULL)
{
/* Allocate a database from the free list. */
database = Kernel->db->freeDatabase;
Kernel->db->freeDatabase = database->next;
}
else
{
gctPOINTER pointer = gcvNULL;
/* Allocate a new database from the heap. */
gcmkONERROR(gckOS_Allocate(Kernel->os,
gcmSIZEOF(gcsDATABASE),
&pointer));
database = pointer;
}
/* Insert the database into the hash. */
database->next = Kernel->db->db[slot];
Kernel->db->db[slot] = database;
/* Save the hash slot. */
database->slot = slot;
/* Release the database mutex. */
gcmkONERROR(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
/* Return the database. */
*Database = database;
/* Success. */
gcmkFOOTER_ARG("*Database=0x%x", *Database);
return gcvSTATUS_OK;
OnError:
if (acquired)
{
/* Release the database mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
** gckKERNEL_NewRecord
**
** Create a new database record structure and insert it to the head of the
** database.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** gcsDATABASE_PTR Database
** Pointer to a database structure.
**
** OUTPUT:
**
** gcsDATABASE_RECORD_PTR * Record
** Pointer to a variable receiving the database record structure
** pointer on success.
*/
static gceSTATUS
gckKERNEL_NewRecord(
IN gckKERNEL Kernel,
IN gcsDATABASE_PTR Database,
IN gctUINT32 Slot,
OUT gcsDATABASE_RECORD_PTR * Record
)
{
gceSTATUS status;
gctBOOL acquired = gcvFALSE;
gcsDATABASE_RECORD_PTR record = gcvNULL;
gcmkHEADER_ARG("Kernel=0x%x Database=0x%x", Kernel, Database);
/* Acquire the database mutex. */
gcmkONERROR(
gckOS_AcquireMutex(Kernel->os, Kernel->db->dbMutex, gcvINFINITE));
acquired = gcvTRUE;
if (Kernel->db->freeRecord != gcvNULL)
{
/* Allocate the record from the free list. */
record = Kernel->db->freeRecord;
Kernel->db->freeRecord = record->next;
}
else
{
gctPOINTER pointer = gcvNULL;
/* Allocate the record from the heap. */
gcmkONERROR(gckOS_Allocate(Kernel->os,
gcmSIZEOF(gcsDATABASE_RECORD),
&pointer));
record = pointer;
}
/* Insert the record in the database. */
record->next = Database->list[Slot];
Database->list[Slot] = record;
/* Release the database mutex. */
gcmkONERROR(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
/* Return the record. */
*Record = record;
/* Success. */
gcmkFOOTER_ARG("*Record=0x%x", *Record);
return gcvSTATUS_OK;
OnError:
if (acquired)
{
/* Release the database mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
}
if (record != gcvNULL)
{
gcmkVERIFY_OK(gcmkOS_SAFE_FREE(Kernel->os, record));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
/*******************************************************************************
** gckKERNEL_NewDatabase
**
** Create a new database structure and insert it to the head of the hash list.
**
** INPUT:
**
** gckKERNEL Kernel
** Pointer to a gckKERNEL object.
**
** u32 ProcessID
** ProcessID that identifies the database.
**
** OUTPUT:
**
** gcsDATABASE_PTR * Database
** Pointer to a variable receiving the database structure pointer on
** success.
*/
static gceSTATUS
gckKERNEL_NewDatabase(
IN gckKERNEL Kernel,
IN u32 ProcessID,
OUT gcsDATABASE_PTR * Database
)
{
gceSTATUS status;
gcsDATABASE_PTR database;
int acquired = gcvFALSE;
size_t slot;
gcmkHEADER_ARG("Kernel=0x%x ProcessID=%d", Kernel, ProcessID);
/* Acquire the database mutex. */
gcmkONERROR(gckOS_AcquireMutex(Kernel->os, Kernel->db->dbMutex, gcvINFINITE));
acquired = gcvTRUE;
if (Kernel->db->freeDatabase != NULL)
{
/* Allocate a database from the free list. */
database = Kernel->db->freeDatabase;
Kernel->db->freeDatabase = database->next;
}
else
{
void *pointer = NULL;
/* Allocate a new database from the heap. */
gcmkONERROR(gckOS_Allocate(Kernel->os,
sizeof(gcsDATABASE),
&pointer));
database = pointer;
}
/* Compute the hash for the database. */
slot = ProcessID % ARRAY_SIZE(Kernel->db->db);
/* Insert the database into the hash. */
database->next = Kernel->db->db[slot];
Kernel->db->db[slot] = database;
/* Save the hash slot. */
database->slot = slot;
/* Release the database mutex. */
gcmkONERROR(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
/* Return the database. */
*Database = database;
/* Success. */
gcmkFOOTER_ARG("*Database=0x%x", *Database);
return gcvSTATUS_OK;
OnError:
if (acquired)
{
/* Release the database mutex. */
gcmkVERIFY_OK(gckOS_ReleaseMutex(Kernel->os, Kernel->db->dbMutex));
}
/* Return the status. */
gcmkFOOTER();
return status;
}
