Changes in uspace/lib/c/generic/ddi.c [b5c2f56:8cd680c] in mainline

File:

• uspace/lib/c/generic/ddi.c (modified) (8 diffs)

uspace/lib/c/generic/ddi.c

@@ -42 +42 @@
 #include <ddi.h>
 #include <libarch/ddi.h>
+#include <device/hw_res.h>
+#include <device/hw_res_parsed.h>
+#include <device/pio_window.h>
 #include <libc.h>
 #include <task.h>
@@ -68 +71 @@
  * @param flags Flags for the new address space area.
  * @param virt  Virtual address of the starting page.
- *
- * @return EOK on success
- * @return EPERM if the caller lacks the CAP_MEM_MANAGER capability
- * @return ENOENT if there is no task with specified ID
+ *              If set to AS_AREA_ANY ((void *) -1), a suitable value
+ *              is found by the kernel, otherwise the kernel tries to
+ *              obey the desired value.
+ *
+ * @return EOK on success.
+ * @return EPERM if the caller lacks the CAP_MEM_MANAGER capability.
  * @return ENOMEM if there was some problem in creating
  *         the address space area.
  *
  */
-int physmem_map(void *phys, size_t pages, unsigned int flags, void **virt)
+int physmem_map(uintptr_t phys, size_t pages, unsigned int flags, void **virt)
 {
         return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
@@ -82 +87 @@
 }
 
+/** Unmap a piece of physical memory to task.
+ *
+ * Caller of this function must have the CAP_MEM_MANAGER capability.
+ *
+ * @param virt Virtual address from the phys-mapped region.
+ *
+ * @return EOK on success.
+ * @return EPERM if the caller lacks the CAP_MEM_MANAGER capability.
+ *
+ */
+int physmem_unmap(void *virt)
+{
+        return __SYSCALL1(SYS_PHYSMEM_UNMAP, (sysarg_t) virt);
+}
+
+/** Lock a piece physical memory for DMA transfers.
+ *
+ * The mapping of the specified virtual memory address
+ * to physical memory address is locked in order to
+ * make it safe for DMA transferts.
+ *
+ * Caller of this function must have the CAP_MEM_MANAGER capability.
+ *
+ * @param virt      Virtual address of the memory to be locked.
+ * @param size      Number of bytes to lock.
+ * @param map_flags Desired virtual memory area flags.
+ * @param flags     Flags for the physical memory address.
+ * @param phys      Locked physical memory address.
+ *
+ * @return EOK on success.
+ * @return EPERM if the caller lacks the CAP_MEM_MANAGER capability.
+ * @return ENOMEM if there was some problem in creating
+ *         the address space area.
+ *
+ */
 int dmamem_map(void *virt, size_t size, unsigned int map_flags,
-    unsigned int flags, void **phys)
+    unsigned int flags, uintptr_t *phys)
 {
         return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
@@ -90 +130 @@
 }
 
-int dmamem_map_anonymous(size_t size, unsigned int map_flags,
-    unsigned int flags, void **phys, void **virt)
-{
+/** Map a piece of physical memory suitable for DMA transfers.
+ *
+ * Caller of this function must have the CAP_MEM_MANAGER capability.
+ *
+ * @param size       Number of bytes to map.
+ * @param constraint Bit mask defining the contraint on the physical
+ *                   address to be mapped.
+ * @param map_flags  Desired virtual memory area flags.
+ * @param flags      Flags for the physical memory address.
+ * @param virt       Virtual address of the starting page.
+ *                   If set to AS_AREA_ANY ((void *) -1), a suitable value
+ *                   is found by the kernel, otherwise the kernel tries to
+ *                   obey the desired value.
+ *
+ * @return EOK on success.
+ * @return EPERM if the caller lacks the CAP_MEM_MANAGER capability.
+ * @return ENOMEM if there was some problem in creating
+ *         the address space area.
+ *
+ */
+int dmamem_map_anonymous(size_t size, uintptr_t constraint,
+    unsigned int map_flags, unsigned int flags, uintptr_t *phys, void **virt)
+{
+        *phys = constraint;
+        
         return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
             (sysarg_t) map_flags, (sysarg_t) flags | DMAMEM_FLAGS_ANONYMOUS,
@@ -132 +194 @@
         
         return __SYSCALL1(SYS_IOSPACE_ENABLE, (sysarg_t) &arg);
+}
+
+/** Disable I/O space range to task.
+ *
+ * Caller of this function must have the IO_MEM_MANAGER capability.
+ *
+ * @param id     Task ID.
+ * @param ioaddr Starting address of the I/O range.
+ * @param size   Size of the range.
+ *
+ * @return EOK on success
+ * @return EPERM if the caller lacks the CAP_IO_MANAGER capability
+ * @return ENOENT if there is no task with specified ID
+ *
+ */
+static int iospace_disable(task_id_t id, void *ioaddr, size_t size)
+{
+        const ddi_ioarg_t arg = {
+                .task_id = id,
+                .ioaddr = ioaddr,
+                .size = size
+        };
+        
+        return __SYSCALL1(SYS_IOSPACE_DISABLE, (sysarg_t) &arg);
+}
+
+/** Enable PIO for specified address range.
+ *
+ * @param range I/O range to be enable.
+ * @param virt  Virtual address for application's PIO operations. 
+ */
+int pio_enable_range(addr_range_t *range, void **virt)
+{
+        return pio_enable(RNGABSPTR(*range), RNGSZ(*range), virt);
+}
+
+/** Enable PIO for specified HW resource wrt. to the PIO window.
+ *
+ * @param win      PIO window. May be NULL if the resources are known to be
+ *                 absolute.
+ * @param res      Resources specifying the I/O range wrt. to the PIO window.
+ * @param virt     Virtual address for application's PIO operations.
+ *
+ * @return EOK on success.
+ * @return Negative error code on failure.
+ *
+ */
+int pio_enable_resource(pio_window_t *win, hw_resource_t *res, void **virt)
+{
+        uintptr_t addr;
+        size_t size;
+
+        switch (res->type) {
+        case IO_RANGE:
+                addr = res->res.io_range.address;
+                if (res->res.io_range.relative) {
+                        if (!win)
+                                return EINVAL;
+                        addr += win->io.base;
+                }
+                size = res->res.io_range.size;
+                break;
+        case MEM_RANGE:
+                addr = res->res.mem_range.address;
+                if (res->res.mem_range.relative) {
+                        if (!win)
+                                return EINVAL;
+                        addr += win->mem.base;
+                }
+                size = res->res.mem_range.size;
+                break;
+        default:
+                return EINVAL;
+        }
+
+        return pio_enable((void *) addr, size, virt);   
 }
 
@@ -158 +296 @@
         if (!virt)
                 return EINVAL;
-
-        void *phys_frame =
-            (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
-        size_t offset = pio_addr - phys_frame;
+        
+        uintptr_t phys_frame =
+            ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
+        size_t offset = (uintptr_t) pio_addr - phys_frame;
         size_t pages = SIZE2PAGES(offset + size);
         
-        void *virt_page;
+        void *virt_page = AS_AREA_ANY;
         int rc = physmem_map(phys_frame, pages,
             AS_AREA_READ | AS_AREA_WRITE, &virt_page);
@@ -174 +312 @@
 }
 
+/** Disable PIO for specified I/O range.
+ *
+ * @param virt     I/O start address.
+ * @param size     Size of the I/O region.
+ *
+ * @return EOK on success.
+ * @return Negative error code on failure.
+ *
+ */
+int pio_disable(void *virt, size_t size)
+{
+#ifdef IO_SPACE_BOUNDARY
+        if (virt < IO_SPACE_BOUNDARY)
+                return iospace_disable(task_get_id(), virt, size);
+#else
+        (void) iospace_disable;
+#endif
+        return physmem_unmap(virt);
+}
+
 void pio_write_8(ioport8_t *reg, uint8_t val)
 {
@@ -213 +371 @@
 }
 
-/** Register IRQ notification.
- *
- * @param inr    IRQ number.
- * @param devno  Device number of the device generating inr.
- * @param method Use this method for notifying me.
- * @param ucode  Top-half pseudocode handler.
- *
- * @return Value returned by the kernel.
- *
- */
-int irq_register(int inr, int devno, int method, irq_code_t *ucode)
-{
-        return __SYSCALL4(SYS_IRQ_REGISTER, inr, devno, method,
-            (sysarg_t) ucode);
-}
-
-/** Unregister IRQ notification.
- *
- * @param inr   IRQ number.
- * @param devno Device number of the device generating inr.
- *
- * @return Value returned by the kernel.
- *
- */
-int irq_unregister(int inr, int devno)
-{
-        return __SYSCALL2(SYS_IRQ_UNREGISTER, inr, devno);
-}
-
 /** @}
  */