Contents
IoReadMmBuffer8(), IoReadMmBuffer16(), IoReadMmBuffer32()
These functions are declared in the coresrv/io/mmio.h file.
void IoReadMmBuffer8(volatile rtl_uint8_t *baseReg, rtl_uint8_t *dst,
rtl_size_t cnt);
void IoReadMmBuffer16(volatile rtl_uint16_t *baseReg, rtl_uint16_t *dst,
rtl_size_t cnt);
void IoReadMmBuffer32(volatile rtl_uint32_t *baseReg, rtl_uint32_t *dst,
rtl_size_t cnt);
These functions read the sequence of one-, two-, or four-byte values, respectively, from the register mapped to the baseReg address and write the values to the dst array. cnt is the length of the sequence.
IoReadMmReg8(), IoReadMmReg16(), IoReadMmReg32()
These functions are declared in the coresrv/io/mmio.h file.
rtl_uint8_t IoReadMmReg8(volatile void *reg);
rtl_uint16_t IoReadMmReg16(volatile void *reg);
rtl_uint32_t IoReadMmReg32(volatile void *reg);
These functions read one, two, or four bytes, respectively, from the register mapped to the reg address and return the read value.
IoWriteMmBuffer8(), IoWriteMmBuffer16(), IoWriteMmBuffer32()
These functions are declared in the coresrv/io/mmio.h file.
void IoWriteMmBuffer8(volatile rtl_uint8_t *baseReg, const rtl_uint8_t *src,
rtl_size_t cnt);
void IoWriteMmBuffer16(volatile rtl_uint16_t *baseReg, const rtl_uint16_t *src,
rtl_size_t cnt);
void IoWriteMmBuffer32(volatile rtl_uint32_t *baseReg, const rtl_uint32_t *src,
rtl_size_t cnt);
These functions write the sequence of one-, two-, or four-byte values, respectively, from the src array to the register mapped to the baseReg address. cnt is the length of the sequence.
IoWriteMmReg8(), IoWriteMmReg16(), IoWriteMmReg32()
These functions are declared in the coresrv/io/mmio.h file.
void IoWriteMmReg8(volatile void *reg, rtl_uint8_t data);
void IoWriteMmReg16(volatile void *reg, rtl_uint16_t data);
void IoWriteMmReg32(volatile void *reg, rtl_uint32_t data);
These functions write a one-, two-, or four-byte data value to the register mapped to the reg address.
KnIoMapMem()
This function is declared in the coresrv/io/mmio.h file.
Retcode KnIoMapMem(Handle rid, rtl_uint32_t prot, rtl_uint32_t attr,
void **addr, Handle *handle);
This function maps the registered memory area that was assigned the handle rid to the address space of the process.
You can use the prot and attr input parameters to change the memory area protection attributes, or to disable caching.
Output parameters:
addris the pointer to the starting address of the virtual memory area.handlerefers to the handle of the virtual memory area.
Returns rcOk if successful.
prot refers to the attributes of memory area protection via MMU, with the following possible values:
- VMM_FLAG_READ – allow read.
- VMM_FLAG_WRITE – allow write.
- VMM_FLAG_READ | VMM_FLAG_WRITE – allow read and write.
- VMM_FLAG_RWX_MASK or VMM_FLAG_READ | VMM_FLAG_WRITE | VMM_FLAG_EXECUTE – full access to the memory area (these entries are equivalent).
attr – memory area attributes. Possible values:
- VMM_FLAG_CACHE_DISABLE – disable caching.
- VMM_FLAG_LOW_GUARD and VMM_FLAG_HIGH_GUARD add a protective page before and after the allocated memory, respectively.
- VMM_FLAG_ALIAS – flag indicates that the memory area may have multiple virtual addresses.
Example
static Retcode MemInit(IOMem *resource)
{
Retcode rc = rcFail;
rc = KnRegisterPhyMem(resource->base,
resource->size,
&resource->handle);
if (rc == rcOk)
rc = KnIoMapMem(resource->handle,
VMM_FLAG_READ | VMM_FLAG_WRITE,
VMM_FLAG_CACHE_DISABLE,
(void **) &resource->addr, &resource->permitHandle);
if (rc == rcOk)
resource->addr = ((rtl_uint8_t *) resource->addr
+ resource->offset);
return rc;
}
KnRegisterPhyMem()
This function is declared in the coresrv/io/mmio.h file.
Retcode KnRegisterPhyMem(rtl_uint64_t addr, rtl_size_t size, Handle *outRid);
This function registers a memory area with the specified size (in bytes) and beginning at the address addr.
If registration is successful, the handle assigned to the memory area will be passed to the outRid parameter, and the function will return rcOk.
The address addr must be page-aligned, and the specified size must be a multiple of the page size.
For a usage example, see KnIoMapMem().
If a memory area is no longer being used, it must be freed by using the KnIoClose() function.