Subversion Repositories HelenOS-historic

Rev

Rev 1589 | Rev 1708 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (C) 2006 Jakub Jermar
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. /** @defgroup ddi Device Driver Interface
  30.  * @ingroup kernel
  31.  * @{
  32.  * @}
  33.  */
  34.  
  35.  /** @addtogroup genericddi generic
  36.  * @ingroup ddi
  37.  * @{
  38.  */
  39.  
  40. /**
  41.  * @file
  42.  * @brief   Device Driver Interface functions.
  43.  *
  44.  * This file contains functions that comprise the Device Driver Interface.
  45.  * These are the functions for mapping physical memory and enabling I/O
  46.  * space to tasks.
  47.  */
  48.  
  49. #include <ddi/ddi.h>
  50. #include <ddi/ddi_arg.h>
  51. #include <proc/task.h>
  52. #include <security/cap.h>
  53. #include <mm/frame.h>
  54. #include <mm/as.h>
  55. #include <synch/spinlock.h>
  56. #include <syscall/copy.h>
  57. #include <arch.h>
  58. #include <align.h>
  59. #include <errno.h>
  60.  
  61. /** Map piece of physical memory into virtual address space of current task.
  62.  *
  63.  * @param pf Physical frame address of the starting frame.
  64.  * @param vp Virtual page address of the starting page.
  65.  * @param pages Number of pages to map.
  66.  * @param flags Address space area flags for the mapping.
  67.  *
  68.  * @return 0 on success, EPERM if the caller lacks capabilities to use this syscall,
  69.  *     ENOENT if there is no task matching the specified ID and ENOMEM if
  70.  *     there was a problem in creating address space area.
  71.  */
  72. static int ddi_physmem_map(__address pf, __address vp, count_t pages, int flags)
  73. {
  74.     ipl_t ipl;
  75.     cap_t caps;
  76.     mem_backend_data_t backend_data;
  77.  
  78.     backend_data.base = pf;
  79.     backend_data.frames = pages;
  80.    
  81.     /*
  82.      * Make sure the caller is authorised to make this syscall.
  83.      */
  84.     caps = cap_get(TASK);
  85.     if (!(caps & CAP_MEM_MANAGER))
  86.         return EPERM;
  87.  
  88.     ipl = interrupts_disable();
  89.     spinlock_lock(&TASK->lock);
  90.    
  91.     if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp, AS_AREA_ATTR_NONE,
  92.         &phys_backend, &backend_data)) {
  93.         /*
  94.          * The address space area could not have been created.
  95.          * We report it using ENOMEM.
  96.          */
  97.         spinlock_unlock(&TASK->lock);
  98.         interrupts_restore(ipl);
  99.         return ENOMEM;
  100.     }
  101.    
  102.     /*
  103.      * Mapping is created on-demand during page fault.
  104.      */
  105.    
  106.     spinlock_unlock(&TASK->lock);
  107.     interrupts_restore(ipl);
  108.     return 0;
  109. }
  110.  
  111. /** Enable range of I/O space for task.
  112.  *
  113.  * @param id Task ID of the destination task.
  114.  * @param ioaddr Starting I/O address.
  115.  * @param size Size of the enabled I/O space..
  116.  *
  117.  * @return 0 on success, EPERM if the caller lacks capabilities to use this syscall,
  118.  *     ENOENT if there is no task matching the specified ID.
  119.  */
  120. static int ddi_iospace_enable(task_id_t id, __address ioaddr, size_t size)
  121. {
  122.     ipl_t ipl;
  123.     cap_t caps;
  124.     task_t *t;
  125.     int rc;
  126.    
  127.     /*
  128.      * Make sure the caller is authorised to make this syscall.
  129.      */
  130.     caps = cap_get(TASK);
  131.     if (!(caps & CAP_IO_MANAGER))
  132.         return EPERM;
  133.    
  134.     ipl = interrupts_disable();
  135.     spinlock_lock(&tasks_lock);
  136.    
  137.     t = task_find_by_id(id);
  138.    
  139.     if (!t) {
  140.         /*
  141.          * There is no task with the specified ID.
  142.          */
  143.         spinlock_unlock(&tasks_lock);
  144.         interrupts_restore(ipl);
  145.         return ENOENT;
  146.     }
  147.  
  148.     /* Lock the task and release the lock protecting tasks_btree. */
  149.     spinlock_lock(&t->lock);
  150.     spinlock_unlock(&tasks_lock);
  151.  
  152.     rc = ddi_iospace_enable_arch(t, ioaddr, size);
  153.    
  154.     spinlock_unlock(&t->lock);
  155.     interrupts_restore(ipl);
  156.     return rc;
  157. }
  158.  
  159. /** Wrapper for SYS_MAP_PHYSMEM syscall.
  160.  *
  161.  * @param phys_base Physical base address to map
  162.  * @param virt_base Destination virtual address
  163.  * @param pages Number of pages
  164.  * @param flags Flags of newly mapped pages
  165.  *
  166.  * @return 0 on success, otherwise it returns error code found in errno.h
  167.  */
  168. __native sys_physmem_map(__native phys_base, __native virt_base, __native pages,
  169.              __native flags)
  170. {
  171.     return (__native) ddi_physmem_map(ALIGN_DOWN((__address) phys_base, FRAME_SIZE),
  172.                       ALIGN_DOWN((__address) virt_base, PAGE_SIZE), (count_t) pages,
  173.                       (int) flags);
  174. }
  175.  
  176. /** Wrapper for SYS_ENABLE_IOSPACE syscall.
  177.  *
  178.  * @param User space address of DDI argument structure.
  179.  *
  180.  * @return 0 on success, otherwise it returns error code found in errno.h
  181.  */
  182. __native sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
  183. {
  184.     ddi_ioarg_t arg;
  185.     int rc;
  186.    
  187.     rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
  188.     if (rc != 0)
  189.         return (__native) rc;
  190.        
  191.     return (__native) ddi_iospace_enable((task_id_t) arg.task_id, (__address) arg.ioaddr, (size_t) arg.size);
  192. }
  193.  
  194. /** Disable or enable preemption.
  195.  *
  196.  * @param enable If non-zero, the preemption counter will be decremented, leading to potential
  197.  *       enabling of preemption. Otherwise the preemption counter will be incremented,
  198.  *       preventing preemption from occurring.
  199.  *
  200.  * @return Zero on success or EPERM if callers capabilities are not sufficient.
  201.  */
  202. __native sys_preempt_control(int enable)
  203. {
  204.         if (! cap_get(TASK) & CAP_PREEMPT_CONTROL)
  205.                 return EPERM;
  206.         if (enable)
  207.                 preemption_enable();
  208.         else
  209.                 preemption_disable();
  210.         return 0;
  211. }
  212.  
  213.  /** @}
  214.  */
  215.  
  216.