Changes in kernel/generic/src/ddi/ddi.c [c0699467:3164e3b] in mainline

File:

• kernel/generic/src/ddi/ddi.c (modified) (12 diffs)

kernel/generic/src/ddi/ddi.c

@@ -45 +45 @@
 #include <mm/frame.h>
 #include <mm/as.h>
+#include <mm/page.h>
 #include <synch/mutex.h>
 #include <syscall/copy.h>
@@ -52 +53 @@
 #include <errno.h>
 #include <trace.h>
+#include <bitops.h>
 
 /** This lock protects the parea_btree. */
@@ -87 +89 @@
 /** Map piece of physical memory into virtual address space of current task.
  *
- * @param pf    Physical address of the starting frame.
- * @param vp    Virtual address of the starting page.
+ * @param phys  Physical address of the starting frame.
  * @param pages Number of pages to map.
  * @param flags Address space area flags for the mapping.
- *
- * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *         syscall, EBADMEM if pf or vf is not page aligned, ENOENT if there
- *         is no task matching the specified ID or the physical address space
- *         is not enabled for mapping and ENOMEM if there was a problem in
- *         creating address space area.
- *
- */
-NO_TRACE static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages,
-    unsigned int flags)
+ * @param virt  Virtual address of the starting page.
+ * @param bound Lowest virtual address bound.
+ *
+ * @return EOK on success.
+ * @return EPERM if the caller lacks capabilities to use this syscall.
+ * @return EBADMEM if phys is not page aligned.
+ * @return ENOENT if there is no task matching the specified ID or
+ *         the physical address space is not enabled for mapping.
+ * @return ENOMEM if there was a problem in creating address space area.
+ *
+ */
+NO_TRACE static int physmem_map(uintptr_t phys, size_t pages,
+    unsigned int flags, uintptr_t *virt, uintptr_t bound)
 {
         ASSERT(TASK);
         
-        if ((pf % FRAME_SIZE) != 0)
-                return EBADMEM;
-        
-        if ((vp % PAGE_SIZE) != 0)
+        if ((phys % FRAME_SIZE) != 0)
                 return EBADMEM;
         
@@ -118 +119 @@
         
         mem_backend_data_t backend_data;
-        backend_data.base = pf;
+        backend_data.base = phys;
         backend_data.frames = pages;
         
@@ -129 +130 @@
         btree_node_t *nodep;
         parea_t *parea = (parea_t *) btree_search(&parea_btree,
-            (btree_key_t) pf, &nodep);
+            (btree_key_t) phys, &nodep);
         
         if ((parea != NULL) && (parea->frames >= pages)) {
@@ -149 +150 @@
         
         irq_spinlock_lock(&zones.lock, true);
-        size_t znum = find_zone(ADDR2PFN(pf), pages, 0);
+        size_t znum = find_zone(ADDR2PFN(phys), pages, 0);
         
         if (znum == (size_t) -1) {
@@ -165 +166 @@
         }
         
-        if (zones.info[znum].flags & ZONE_FIRMWARE) {
-                /*
-                 * Frames are part of firmware
+        if (zones.info[znum].flags & (ZONE_FIRMWARE | ZONE_RESERVED)) {
+                /*
+                 * Frames are part of firmware or reserved zone
                  * -> allow mapping for privileged tasks.
                  */
@@ -182 +183 @@
         
 map:
-        if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp,
-            AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
+        if (!as_area_create(TASK->as, flags, FRAMES2SIZE(pages),
+            AS_AREA_ATTR_NONE, &phys_backend, &backend_data, virt, bound)) {
                 /*
                  * The address space area was not created.
@@ -207 +208 @@
 }
 
+NO_TRACE static int physmem_unmap(uintptr_t virt)
+{
+        // TODO: implement unmap
+        return EOK;
+}
+
+/** Wrapper for SYS_PHYSMEM_MAP syscall.
+ *
+ * @param phys     Physical base address to map
+ * @param pages    Number of pages
+ * @param flags    Flags of newly mapped pages
+ * @param virt_ptr Destination virtual address
+ * @param bound    Lowest virtual address bound.
+ *
+ * @return 0 on success, otherwise it returns error code found in errno.h
+ *
+ */
+sysarg_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
+    void *virt_ptr, uintptr_t bound)
+{
+        uintptr_t virt = (uintptr_t) -1;
+        int rc = physmem_map(ALIGN_DOWN(phys, FRAME_SIZE), pages, flags,
+            &virt, bound);
+        if (rc != EOK)
+                return rc;
+        
+        rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
+        if (rc != EOK) {
+                physmem_unmap((uintptr_t) virt);
+                return rc;
+        }
+        
+        return EOK;
+}
+
+sysarg_t sys_physmem_unmap(uintptr_t virt)
+{
+        return physmem_unmap(virt);
+}
+
 /** Enable range of I/O space for task.
  *
@@ -217 +258 @@
  *
  */
-NO_TRACE static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr,
-    size_t size)
+NO_TRACE static int iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
 {
         /*
@@ -243 +283 @@
         /* Lock the task and release the lock protecting tasks_btree. */
         irq_spinlock_exchange(&tasks_lock, &task->lock);
-        
         int rc = ddi_iospace_enable_arch(task, ioaddr, size);
-        
         irq_spinlock_unlock(&task->lock, true);
         
         return rc;
-}
-
-/** Wrapper for SYS_PHYSMEM_MAP syscall.
- *
- * @param phys_base Physical base address to map
- * @param virt_base Destination virtual address
- * @param pages Number of pages
- * @param flags Flags of newly mapped pages
- *
- * @return 0 on success, otherwise it returns error code found in errno.h
- *
- */
-sysarg_t sys_physmem_map(sysarg_t phys_base, sysarg_t virt_base,
-    sysarg_t pages, sysarg_t flags)
-{
-        return (sysarg_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
-            FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
-            (size_t) pages, (int) flags);
 }
 
@@ -283 +303 @@
                 return (sysarg_t) rc;
         
-        return (sysarg_t) ddi_iospace_enable((task_id_t) arg.task_id,
+        return (sysarg_t) iospace_enable((task_id_t) arg.task_id,
             (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 
+sysarg_t sys_iospace_disable(ddi_ioarg_t *uspace_io_arg)
+{
+        // TODO: implement
+        return ENOTSUP;
+}
+
+NO_TRACE static int dmamem_map(uintptr_t virt, size_t size, unsigned int map_flags,
+    unsigned int flags, void **phys)
+{
+        ASSERT(TASK);
+        
+        // TODO: implement locking of non-anonymous mapping
+        return page_find_mapping(virt, phys);
+}
+
+NO_TRACE static int dmamem_map_anonymous(size_t size, unsigned int map_flags,
+    unsigned int flags, void **phys, uintptr_t *virt, uintptr_t bound)
+{
+        ASSERT(TASK);
+        
+        size_t pages = SIZE2FRAMES(size);
+        uint8_t order;
+        
+        /* We need the 2^order >= pages */
+        if (pages == 1)
+                order = 0;
+        else
+                order = fnzb(pages - 1) + 1;
+        
+        *phys = frame_alloc_noreserve(order, 0);
+        if (*phys == NULL)
+                return ENOMEM;
+        
+        mem_backend_data_t backend_data;
+        backend_data.base = (uintptr_t) *phys;
+        backend_data.frames = pages;
+        
+        if (!as_area_create(TASK->as, map_flags, size,
+            AS_AREA_ATTR_NONE, &phys_backend, &backend_data, virt, bound)) {
+                frame_free_noreserve((uintptr_t) *phys);
+                return ENOMEM;
+        }
+        
+        return EOK;
+}
+
+NO_TRACE static int dmamem_unmap(uintptr_t virt, size_t size)
+{
+        // TODO: implement unlocking & unmap
+        return EOK;
+}
+
+NO_TRACE static int dmamem_unmap_anonymous(uintptr_t virt)
+{
+        // TODO: implement unlocking & unmap
+        return EOK;
+}
+
+sysarg_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
+    void *phys_ptr, void *virt_ptr, uintptr_t bound)
+{
+        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0) {
+                /*
+                 * Non-anonymous DMA mapping
+                 */
+                
+                void *phys;
+                int rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
+                    flags, &phys);
+                
+                if (rc != EOK)
+                        return rc;
+                
+                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+                if (rc != EOK) {
+                        dmamem_unmap((uintptr_t) virt_ptr, size);
+                        return rc;
+                }
+        } else {
+                /*
+                 * Anonymous DMA mapping
+                 */
+                
+                void *phys;
+                uintptr_t virt = (uintptr_t) -1;
+                int rc = dmamem_map_anonymous(size, map_flags, flags,
+                    &phys, &virt, bound);
+                if (rc != EOK)
+                        return rc;
+                
+                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+                if (rc != EOK) {
+                        dmamem_unmap_anonymous((uintptr_t) virt);
+                        return rc;
+                }
+                
+                rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
+                if (rc != EOK) {
+                        dmamem_unmap_anonymous((uintptr_t) virt);
+                        return rc;
+                }
+        }
+        
+        return EOK;
+}
+
+sysarg_t sys_dmamem_unmap(uintptr_t virt, size_t size, unsigned int flags)
+{
+        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0)
+                return dmamem_unmap(virt, size);
+        else
+                return dmamem_unmap_anonymous(virt);
+}
+
 /** @}
  */