WebSVN – HelenOS – Diff – /branches/dynload/kernel/generic/src/ddi/ddi.c

  */
 /** @addtogroup genericddi
  * @{
  */
 /**
  * @file
- * @brief   Device Driver Interface functions.
+ * @brief Device Driver Interface functions.
+ *
  * This file contains functions that comprise the Device Driver Interface.
  * These are the functions for mapping physical memory and enabling I/O
  * space to tasks.
  */
 #include <security/cap.h>
 #include <mm/frame.h>
 #include <mm/as.h>
 #include <synch/spinlock.h>
 #include <syscall/copy.h>
-#include <adt/list.h>
+#include <adt/btree.h>
 #include <arch.h>
 #include <align.h>
 #include <errno.h>
 /** This lock protects the parea_btree. */
 SPINLOCK_INITIALIZE(parea_lock);
-/** List with enabled physical memory areas. */
+/** B+tree with enabled physical memory areas. */
-static LIST_INITIALIZE(parea_head);
-/** Physical memory area for devices. */
-static parea_t dev_area;
+static btree_t parea_btree;
 /** Initialize DDI. */
 void ddi_init(void)
+{
-    hw_area(&dev_area.pbase, &dev_area.frames);
-    ddi_parea_register(&dev_area);
+    btree_create(&parea_btree);
+}
 /** Enable piece of physical memory for mapping by physmem_map().
+ *
  * @param parea Pointer to physical area structure.
+ *
- * @todo This function doesn't check for overlaps. It depends on the kernel to
- * create disjunct physical memory areas.
  */
 void ddi_parea_register(parea_t *parea)
+{
-    ipl_t ipl;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&parea_lock);
     /*
-     * TODO: we should really check for overlaps here.
-     * However, we should be safe because the kernel is pretty sane.
+     * We don't check for overlaps here as the kernel is pretty sane.
      */
-    link_initialize(&parea->link);
-    list_append(&parea->link, &parea_head);
+    btree_insert(&parea_btree, (btree_key_t) parea->pbase, parea, NULL);
     spinlock_unlock(&parea_lock);
     interrupts_restore(ipl);
+}
 /** Map piece of physical memory into virtual address space of current task.
+ *
- * @param pf Physical address of the starting frame.
+ * @param pf    Physical address of the starting frame.
- * @param vp Virtual address of the starting page.
+ * @param vp    Virtual address of the starting page.
  * @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
- *  syscall, ENOENT if there is no task matching the specified ID or the
+ *         is no task matching the specified ID or the physical address space
- *  physical address space is not enabled for mapping and ENOMEM if there
+ *         is not enabled for mapping and ENOMEM if there was a problem in
- *  was a problem in creating address space area.
+ *         creating address space area.
+ *
  */
-static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, pfn_t pages, int flags)
+static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
+{
-    ipl_t ipl;
-    cap_t caps;
+    ASSERT(TASK);
-    mem_backend_data_t backend_data;
+    ASSERT((pf % FRAME_SIZE) == 0);
-    backend_data.base = pf;
-    backend_data.frames = pages;
+    ASSERT((vp % PAGE_SIZE) == 0);
     /*
      * Make sure the caller is authorised to make this syscall.
      */
-    caps = cap_get(TASK);
+    cap_t caps = cap_get(TASK);
     if (!(caps & CAP_MEM_MANAGER))
         return EPERM;
-    ipl = interrupts_disable();
+    mem_backend_data_t backend_data;
-    /*
-     * Check if the physical memory area is enabled for mapping.
+    backend_data.base = pf;
-     */
-    spinlock_lock(&parea_lock);
+    backend_data.frames = pages;
-    bool fnd = false;
+    ipl_t ipl = interrupts_disable();
-    link_t *cur;
-    for (cur = parea_head.next; cur != &parea_head; cur = cur->next) {
+    /* Find the zone of the physical memory */
-        parea_t *parea = list_get_instance(cur, parea_t, link);
+    spinlock_lock(&zones.lock);
-        if ((parea->pbase <= pf) && (ADDR2PFN(pf - parea->pbase) + pages <= parea->frames)) {
+    count_t znum = find_zone(ADDR2PFN(pf), pages, 0);
-            fnd = true;
+    if (znum == (count_t) -1) {
-            break;
+        /* Frames not found in any zones
+         * -> assume it is hardware device and allow mapping
-        }
+         */
+        spinlock_unlock(&zones.lock);
+        goto map;
+    }
+    if (zones.info[znum].flags & ZONE_FIRMWARE) {
+        /* Frames are part of firmware */
-    spinlock_unlock(&parea_lock);
+        spinlock_unlock(&zones.lock);
+        goto map;
+    }
-    if (!fnd) {
+    if (zone_flags_available(zones.info[znum].flags)) {
-        /*
+        /* Frames are part of physical memory, check if the memory
-         * Physical memory area cannot be mapped.
+         * region is enabled for mapping.
          */
+        spinlock_unlock(&zones.lock);
+        spinlock_lock(&parea_lock);
-        interrupts_restore(ipl);
+        btree_node_t *nodep;
+        parea_t *parea = (parea_t *) btree_search(&parea_btree,
+            (btree_key_t) pf, &nodep);
+        if ((!parea) || (parea->frames < pages))
+            goto err;
+        spinlock_unlock(&parea_lock);
-        return ENOENT;
+        goto map;
+    }
+err:
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
+    return ENOENT;
+map:
     spinlock_lock(&TASK->lock);
-    if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp, AS_AREA_ATTR_NONE,
+    if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp,
-        &phys_backend, &backend_data)) {
+        AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
         /*
          * The address space area could not have been created.
          * We report it using ENOMEM.
          */
         spinlock_unlock(&TASK->lock);
  * @param id Task ID of the destination task.
  * @param ioaddr Starting I/O address.
  * @param size Size of the enabled I/O space..
+ *
  * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *  syscall, ENOENT if there is no task matching the specified ID.
+ *           syscall, ENOENT if there is no task matching the specified ID.
+ *
  */
 static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
+{
-    ipl_t ipl;
-    cap_t caps;
-    task_t *t;
-    int rc;
     /*
      * Make sure the caller is authorised to make this syscall.
      */
-    caps = cap_get(TASK);
+    cap_t caps = cap_get(TASK);
     if (!(caps & CAP_IO_MANAGER))
         return EPERM;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&tasks_lock);
-    t = task_find_by_id(id);
+    task_t *task = task_find_by_id(id);
-    if ((!t) || (!context_check(CONTEXT, t->context))) {
+    if ((!task) || (!context_check(CONTEXT, task->context))) {
         /*
          * There is no task with the specified ID
          * or the task belongs to a different security
          * context.
          */
         spinlock_unlock(&tasks_lock);
         interrupts_restore(ipl);
         return ENOENT;
+    }
     /* Lock the task and release the lock protecting tasks_btree. */
-    spinlock_lock(&t->lock);
+    spinlock_lock(&task->lock);
     spinlock_unlock(&tasks_lock);
-    rc = ddi_iospace_enable_arch(t, ioaddr, size);
+    int rc = ddi_iospace_enable_arch(task, ioaddr, size);
-    spinlock_unlock(&t->lock);
+    spinlock_unlock(&task->lock);
     interrupts_restore(ipl);
     return rc;
+}
 /** Wrapper for SYS_PHYSMEM_MAP syscall.
+ *
  * @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
+ *
  */
 unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base,
     unative_t pages, unative_t flags)
+{
     return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
         FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
-        (pfn_t) pages, (int) flags);
+        (count_t) pages, (int) flags);
+}
 /** Wrapper for SYS_ENABLE_IOSPACE syscall.
+ *
  * @param uspace_io_arg User space address of DDI argument structure.
+ *
  * @return 0 on success, otherwise it returns error code found in errno.h
+ *
  */
 unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
+{
     ddi_ioarg_t arg;
-    int rc;
-    rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
+    int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
     if (rc != 0)
         return (unative_t) rc;
     return (unative_t) ddi_iospace_enable((task_id_t) arg.task_id,
         (uintptr_t) arg.ioaddr, (size_t) arg.size);
+}
 /** Disable or enable preemption.
+ *
  * @param enable If non-zero, the preemption counter will be decremented,
- *  leading to potential enabling of preemption. Otherwise the preemption
+ *               leading to potential enabling of preemption. Otherwise
+ *               the preemption counter will be incremented, preventing
- *  counter will be incremented, preventing preemption from occurring.
+ *               preemption from occurring.
+ *
  * @return Zero on success or EPERM if callers capabilities are not sufficient.
+ *
  */
 unative_t sys_preempt_control(int enable)
+{
     if (!cap_get(TASK) & CAP_PREEMPT_CONTROL)
         return EPERM;
     if (enable)
         preemption_enable();
     else
         preemption_disable();
     return 0;
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/branches/dynload/kernel/generic/src/ddi/ddi.c – Rev 4343 → 4344