Device segment MMIO map & unmap system calls

Change-Id: I233c2677909c0c16536133c189ebbd21e4415e22
Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/208
Tested-by: Jenkins Server
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

5 files changed, 188 insertions, 20 deletions

diff --git a/src/kernel/devicesegment.C b/src/kernel/devicesegment.C
index 446d17298..6d4a30da9 100644
--- a/src/kernel/devicesegment.C
+++ b/src/kernel/devicesegment.C
@@ -10,59 +10,102 @@
 
 #include <kernel/console.H>
 
+/**
+ * STATIC
+ * @brief Add the device segment
+ */
 void DeviceSegment::init()
 {
     Singleton<DeviceSegment>::instance()._init();
 }
 
+/**
+ * @brief DEPRECATED
+ */
 void* DeviceSegment::mmioMap(void* ra, size_t pages)
 {
     return Singleton<DeviceSegment>::instance()._mmioMap(ra, pages);
 }
 
+/**
+ * @brief DEPRECATED
+ */
 int DeviceSegment::mmioUnmap(void* ea, size_t pages)
 {
     return Singleton<DeviceSegment>::instance()._mmioUnmap(ea, pages);
 }
 
+/**
+ * STATIC
+ * @brief Map a device into the device segment(2TB)
+ */
+void* DeviceSegment::devMap(void *ra, SEG_DATA_SIZES i_devDataSize)
+{
+    return Singleton<DeviceSegment>::instance()._devMap(ra,i_devDataSize);
+}
+
+/**
+ * STATIC
+ * @brief Unmap a device from the device segment(2TB)
+ */
+int DeviceSegment::devUnmap(void *ea)
+{
+    return Singleton<DeviceSegment>::instance()._devUnmap(ea);
+}
+
+/**
+ * @brief Add the device segment
+ */
 void DeviceSegment::_init()
 {
     SegmentManager::addSegment(this, SegmentManager::MMIO_SEGMENT_ID);
 }
 
+/**
+ * @brief Handle a page fault for a device address access
+ * @param i_task[in] - Task pointer to the task requiring the page
+ * @param i_addr[in] - 64-bit address needed to be paged
+ * @return bool - TRUE: Page added to page table
+ *               FALSE: Not a valid address to be paged
+ */
 bool DeviceSegment::handlePageFault(task_t* i_task, uint64_t i_addr)
 {
-    // Check address range.
+    //Verify input address falls within this segment's address range
     if (i_addr < this->getBaseAddress() ||
-        i_addr >= (this->getBaseAddress() + 0x010000000000ull))
+        i_addr >= (this->getBaseAddress() + (1ull << SLBE_s)))
     {
         return false;
     }
 
-    // Check valid device.
+    //Verify the device is mapped
     uint64_t segment_ea = i_addr - this->getBaseAddress();
     size_t idx = segment_ea / ((1ull << SLBE_s) / MMIO_MAP_DEVICES);
     uint64_t device_offset = segment_ea - 
                                 (idx * (1ull << SLBE_s) / MMIO_MAP_DEVICES);
-    
-    if (0 == iv_mmioMap[idx])
+
+    if (0 == iv_mmioMap[idx].addr ||
+        device_offset >= (uint64_t)iv_mmioMap[idx].size)
     {
         return false;
     }
 
     PageTableManager::addEntry((i_addr / PAGESIZE) * PAGESIZE,
-                               (iv_mmioMap[idx] + device_offset) / PAGESIZE,
+                              (iv_mmioMap[idx].addr + device_offset) / PAGESIZE,
                                VmmManager::CI_ACCESS);
     return true;
 }
 
+/**
+ * @brief DEPRECATED
+ */
 void* DeviceSegment::_mmioMap(void* ra, size_t pages)
 {
     for (size_t i = 0; i < MMIO_MAP_DEVICES; i++)
     {
-        if (0 == iv_mmioMap[i])
+        if (0 == iv_mmioMap[i].addr)
         {
-            iv_mmioMap[i] = reinterpret_cast<uint64_t>(ra);
+            iv_mmioMap[i].size = THIRTYTWO_GB;
+            iv_mmioMap[i].addr = reinterpret_cast<uint64_t>(ra);
             return reinterpret_cast<void*>(i * 
                                       ((1ull << SLBE_s) / MMIO_MAP_DEVICES) +
                                       this->getBaseAddress());
@@ -72,20 +115,91 @@ void* DeviceSegment::_mmioMap(void* ra, size_t pages)
     return NULL;
 }
 
+/**
+ * @brief DEPRECATED
+ */
 int DeviceSegment::_mmioUnmap(void* ea, size_t pages)
 {
     uint64_t segment_ea = reinterpret_cast<uint64_t>(ea) - 
                           this->getBaseAddress();
     size_t idx = segment_ea / ((1ull << SLBE_s) / MMIO_MAP_DEVICES);
-    if (0 != iv_mmioMap[idx])
+    if (0 != iv_mmioMap[idx].addr)
     {
-        PageTableManager::delRangePN(iv_mmioMap[idx] / PAGESIZE,
-                                     iv_mmioMap[idx] / PAGESIZE +
+        PageTableManager::delRangePN(iv_mmioMap[idx].addr / PAGESIZE,
+                                     iv_mmioMap[idx].addr / PAGESIZE +
                                         pages);
-        iv_mmioMap[idx] = 0;        
+        iv_mmioMap[idx].addr = 0;
         return 0;
     }
 
     return -1;
 }
 
+/**
+ * @brief Map a device into the device segment(2TB)
+ * @param ra[in] - Void pointer to real address to be mapped in
+ * @param i_devDataSize[in] - Size of device segment block
+ * @return void* - Pointer to beginning virtual address, NULL otherwise
+ */
+void *DeviceSegment::_devMap(void *ra, SEG_DATA_SIZES i_devDataSize)
+{
+    void *segBlock = NULL;
+    if (i_devDataSize <= THIRTYTWO_GB)
+    {
+        //TODO - Use segment block size if/when new device size needed
+        for (size_t i = 0; i < MMIO_MAP_DEVICES; i++)
+        {
+            if (0 == iv_mmioMap[i].addr)
+            {
+                iv_mmioMap[i].size = i_devDataSize;
+                iv_mmioMap[i].addr = reinterpret_cast<uint64_t>(ra);
+                //TODO - Use segment block size if/when new device size needed
+                segBlock = reinterpret_cast<void*>(i *
+                        ((1ull << SLBE_s) / MMIO_MAP_DEVICES) +
+                        this->getBaseAddress());
+                break;
+            }
+        }
+        if (segBlock == NULL)
+        {
+            printk("Unable to map device, no empty segment blocks found\n");
+        }
+    }
+    else
+    {
+        printk("Unsupported device segment size(0x%lX), ",i_devDataSize);
+        printk("for address 0x%lX\n",reinterpret_cast<uint64_t>(ra));
+    }
+
+    return segBlock;
+}
+
+/**
+ * @brief Unmap a device from the device segment(2TB)
+ * @param ea[in] - Void pointer to effective address
+ * @return int - 0 for successful unmap, non-zero otherwise
+ */
+int DeviceSegment::_devUnmap(void *ea)
+{
+    int rc = -1;
+    uint64_t segment_ea = reinterpret_cast<uint64_t>(ea);
+    //Verify input address falls within this segment's address range
+    if (segment_ea < this->getBaseAddress() ||
+        segment_ea >= (this->getBaseAddress() + (1ull << SLBE_s)))
+    {
+        return rc;
+    }
+    segment_ea = segment_ea - this->getBaseAddress();
+    //TODO - Calculate idx by segment block size if/when new device size needed
+    size_t idx = segment_ea / ((1ull << SLBE_s) / MMIO_MAP_DEVICES);
+    if (0 != iv_mmioMap[idx].addr)
+    {
+        //Remove all of the defined block's size (<= 32GB)
+        PageTableManager::delRangePN(iv_mmioMap[idx].addr / PAGESIZE,
+                (iv_mmioMap[idx].addr + iv_mmioMap[idx].size) / PAGESIZE);
+        iv_mmioMap[idx].addr = 0;
+        rc = 0;
+    }
+
+    return rc;
+}
diff --git a/src/kernel/ptmgr.C b/src/kernel/ptmgr.C
index 536930322..c72ca9d24 100644
--- a/src/kernel/ptmgr.C
+++ b/src/kernel/ptmgr.C
@@ -607,11 +607,11 @@ void PageTableManager::writePTE( PageTableEntry* i_pte,
     {
         Dprintk( ">> PageTableManager::writePTE( i_dest=0x%.lX, i_valid=%d )\n", i_dest, i_valid );
 
-        if( i_valid ) {
-            //        printPTE( "Writing", i_dest );
-        } else {
-            printPTE( "Removing", i_dest );
-        }
+        //if( i_valid ) {
+            //printPTE( "Writing", i_dest );
+        //} else {
+            //printPTE( "Removing", i_dest );
+        //}
 
         i_dest->V = 0; /* (other fields don't matter) */
 
diff --git a/src/kernel/segmentmgr.C b/src/kernel/segmentmgr.C
index fae9d3479..625ba61aa 100644
--- a/src/kernel/segmentmgr.C
+++ b/src/kernel/segmentmgr.C
@@ -23,7 +23,7 @@ void SegmentManager::initSLB()
 
 bool SegmentManager::_handlePageFault(task_t* i_task, uint64_t i_addr)
 {
-        // This constant should come from page manager.  Segment size.
+    // This constant should come from page manager.  Segment size.
     const size_t SLBE_s = 40;
 
     // Get segment ID from effective address.
@@ -48,7 +48,7 @@ void SegmentManager::_initSLB()
 {
     // Flush SLB.
     asm volatile("slbia" ::: "memory");
-    isync();  // Ensure slbia completes prior to slbmtes.
+    isync(); // Ensure slbia completes prior to slbmtes.
 
     register uint64_t slbRS, slbRB;
 
diff --git a/src/kernel/syscall.C b/src/kernel/syscall.C
index 6242c4bcb..f96f8d372 100644
--- a/src/kernel/syscall.C
+++ b/src/kernel/syscall.C
@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <kernel/cpu.H>
 #include <kernel/cpumgr.H>
 #include <kernel/scheduler.H>
@@ -57,6 +58,8 @@ namespace Systemcalls
     void MsgWait(task_t*);
     void MmioMap(task_t*);
     void MmioUnmap(task_t*);
+    void DevMap(task_t*);
+    void DevUnmap(task_t*);
     void TimeNanosleep(task_t*);
     void FutexWait(task_t *t);
     void FutexWake(task_t *t);
@@ -82,6 +85,8 @@ namespace Systemcalls
 
 	    &MmioMap,  // MMIO_MAP
 	    &MmioUnmap,  // MMIO_UNMAP
+            &DevMap,
+            &DevUnmap,
 
 	    &TimeNanosleep,  // TIME_NANOSLEEP
 
@@ -309,6 +314,30 @@ namespace Systemcalls
 	TASK_SETRTN(t, VmmManager::mmioUnmap(ea,pages));
     }
 
+    /**
+     * Map a device into virtual memory
+     * @param[in] t:  The task used to map a device
+     */
+    void DevMap(task_t *t)
+    {
+        void *ra = (void*)TASK_GETARG0(t);
+        SEG_DATA_SIZES devDataSize = (SEG_DATA_SIZES)TASK_GETARG1(t);
+
+        kassert(TASK_SETRTN(t, (uint64_t)VmmManager::devMap(ra,devDataSize)) !=
+                NULL);
+    }
+
+    /**
+     * Unmap a device from virtual memory
+     * @param[in] t:  The task used to unmap a device
+     */
+    void DevUnmap(task_t *t)
+    {
+        void *ea = (void*)TASK_GETARG0(t);
+
+        TASK_SETRTN(t, VmmManager::devUnmap(ea));
+    }
+
     void TimeNanosleep(task_t* t)
     {
 	TimeManager::delayTask(t, TASK_GETARG0(t), TASK_GETARG1(t));
diff --git a/src/kernel/vmmmgr.C b/src/kernel/vmmmgr.C
index 98e5a0410..bf6ff10d4 100644
--- a/src/kernel/vmmmgr.C
+++ b/src/kernel/vmmmgr.C
@@ -43,16 +43,42 @@ bool VmmManager::pteMiss(task_t* t, uint64_t effAddr)
     return Singleton<VmmManager>::instance()._pteMiss(t, effAddr);
 }
 
+/**
+ * STATIC
+ * @brief DEPRECATED
+ */
 void* VmmManager::mmioMap(void* ra, size_t pages)
 {
     return DeviceSegment::mmioMap(ra, pages);
 }
 
+/**
+ * STATIC
+ * @brief DEPRECATED
+ */
 int VmmManager::mmioUnmap(void* ea, size_t pages)
 {
     return DeviceSegment::mmioUnmap(ea, pages);
 }
 
+/**
+ * STATIC
+ * @brief A facade to map a device into the device segment(2TB)
+ */
+void* VmmManager::devMap(void* ra, SEG_DATA_SIZES i_devDataSize)
+{
+    return DeviceSegment::devMap(ra, i_devDataSize);
+}
+
+/**
+ * STATIC
+ * @brief A facade to unmap a device from the device segment(2TB)
+ */
+int VmmManager::devUnmap(void* ea)
+{
+    return DeviceSegment::devUnmap(ea);
+}
+
 void VmmManager::initPTEs()
 {
     // Initialize and invalidate the page table
@@ -80,4 +106,3 @@ bool VmmManager::_pteMiss(task_t* t, uint64_t effAddr)
     return rc;
 }
 
-