Subversion Repositories Kolibri OS

Rev

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

  1. /**************************************************************************
  2.  *
  3.  * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the
  8.  * "Software"), to deal in the Software without restriction, including
  9.  * without limitation the rights to use, copy, modify, merge, publish,
  10.  * distribute, sub license, and/or sell copies of the Software, and to
  11.  * permit persons to whom the Software is furnished to do so, subject to
  12.  * the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice (including the
  15.  * next paragraph) shall be included in all copies or substantial portions
  16.  * of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20.  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21.  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22.  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23.  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24.  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  *
  26.  **************************************************************************/
  27. /*
  28.  * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
  29.  */
  30.  
  31. #ifndef _TTM_BO_API_H_
  32. #define _TTM_BO_API_H_
  33.  
  34. #include <drm/drm_hashtab.h>
  35. #include <drm/drm_vma_manager.h>
  36. #include <linux/kref.h>
  37. #include <linux/list.h>
  38. #include <linux/wait.h>
  39. #include <linux/mutex.h>
  40. #include <linux/mm.h>
  41. #include <linux/bitmap.h>
  42. #include <linux/reservation.h>
  43.  
  44. struct ttm_bo_device;
  45.  
  46. struct drm_mm_node;
  47.  
  48.  
  49. /**
  50.  * struct ttm_placement
  51.  *
  52.  * @fpfn:               first valid page frame number to put the object
  53.  * @lpfn:               last valid page frame number to put the object
  54.  * @num_placement:      number of preferred placements
  55.  * @placement:          preferred placements
  56.  * @num_busy_placement: number of preferred placements when need to evict buffer
  57.  * @busy_placement:     preferred placements when need to evict buffer
  58.  *
  59.  * Structure indicating the placement you request for an object.
  60.  */
  61. struct ttm_placement {
  62.         unsigned        fpfn;
  63.         unsigned        lpfn;
  64.         unsigned        num_placement;
  65.         const uint32_t  *placement;
  66.         unsigned        num_busy_placement;
  67.         const uint32_t  *busy_placement;
  68. };
  69.  
  70. /**
  71.  * struct ttm_bus_placement
  72.  *
  73.  * @addr:               mapped virtual address
  74.  * @base:               bus base address
  75.  * @is_iomem:           is this io memory ?
  76.  * @size:               size in byte
  77.  * @offset:             offset from the base address
  78.  * @io_reserved_vm:     The VM system has a refcount in @io_reserved_count
  79.  * @io_reserved_count:  Refcounting the numbers of callers to ttm_mem_io_reserve
  80.  *
  81.  * Structure indicating the bus placement of an object.
  82.  */
  83. struct ttm_bus_placement {
  84.         void            *addr;
  85.         unsigned long   base;
  86.         unsigned long   size;
  87.         unsigned long   offset;
  88.         bool            is_iomem;
  89.         bool            io_reserved_vm;
  90.         uint64_t        io_reserved_count;
  91. };
  92.  
  93.  
  94. /**
  95.  * struct ttm_mem_reg
  96.  *
  97.  * @mm_node: Memory manager node.
  98.  * @size: Requested size of memory region.
  99.  * @num_pages: Actual size of memory region in pages.
  100.  * @page_alignment: Page alignment.
  101.  * @placement: Placement flags.
  102.  * @bus: Placement on io bus accessible to the CPU
  103.  *
  104.  * Structure indicating the placement and space resources used by a
  105.  * buffer object.
  106.  */
  107.  
  108. struct ttm_mem_reg {
  109.         void *mm_node;
  110.         unsigned long start;
  111.         unsigned long size;
  112.         unsigned long num_pages;
  113.         uint32_t page_alignment;
  114.         uint32_t mem_type;
  115.         uint32_t placement;
  116.         struct ttm_bus_placement bus;
  117. };
  118.  
  119. /**
  120.  * enum ttm_bo_type
  121.  *
  122.  * @ttm_bo_type_device: These are 'normal' buffers that can
  123.  * be mmapped by user space. Each of these bos occupy a slot in the
  124.  * device address space, that can be used for normal vm operations.
  125.  *
  126.  * @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers,
  127.  * but they cannot be accessed from user-space. For kernel-only use.
  128.  *
  129.  * @ttm_bo_type_sg: Buffer made from dmabuf sg table shared with another
  130.  * driver.
  131.  */
  132.  
  133. enum ttm_bo_type {
  134.         ttm_bo_type_device,
  135.         ttm_bo_type_kernel,
  136.         ttm_bo_type_sg
  137. };
  138.  
  139. struct ttm_tt;
  140.  
  141. /**
  142.  * struct ttm_buffer_object
  143.  *
  144.  * @bdev: Pointer to the buffer object device structure.
  145.  * @type: The bo type.
  146.  * @destroy: Destruction function. If NULL, kfree is used.
  147.  * @num_pages: Actual number of pages.
  148.  * @acc_size: Accounted size for this object.
  149.  * @kref: Reference count of this buffer object. When this refcount reaches
  150.  * zero, the object is put on the delayed delete list.
  151.  * @list_kref: List reference count of this buffer object. This member is
  152.  * used to avoid destruction while the buffer object is still on a list.
  153.  * Lru lists may keep one refcount, the delayed delete list, and kref != 0
  154.  * keeps one refcount. When this refcount reaches zero,
  155.  * the object is destroyed.
  156.  * @mem: structure describing current placement.
  157.  * @persistent_swap_storage: Usually the swap storage is deleted for buffers
  158.  * pinned in physical memory. If this behaviour is not desired, this member
  159.  * holds a pointer to a persistent shmem object.
  160.  * @ttm: TTM structure holding system pages.
  161.  * @evicted: Whether the object was evicted without user-space knowing.
  162.  * @cpu_writes: For synchronization. Number of cpu writers.
  163.  * @lru: List head for the lru list.
  164.  * @ddestroy: List head for the delayed destroy list.
  165.  * @swap: List head for swap LRU list.
  166.  * @sync_obj: Pointer to a synchronization object.
  167.  * @priv_flags: Flags describing buffer object internal state.
  168.  * @vma_node: Address space manager node.
  169.  * @offset: The current GPU offset, which can have different meanings
  170.  * depending on the memory type. For SYSTEM type memory, it should be 0.
  171.  * @cur_placement: Hint of current placement.
  172.  * @wu_mutex: Wait unreserved mutex.
  173.  *
  174.  * Base class for TTM buffer object, that deals with data placement and CPU
  175.  * mappings. GPU mappings are really up to the driver, but for simpler GPUs
  176.  * the driver can usually use the placement offset @offset directly as the
  177.  * GPU virtual address. For drivers implementing multiple
  178.  * GPU memory manager contexts, the driver should manage the address space
  179.  * in these contexts separately and use these objects to get the correct
  180.  * placement and caching for these GPU maps. This makes it possible to use
  181.  * these objects for even quite elaborate memory management schemes.
  182.  * The destroy member, the API visibility of this object makes it possible
  183.  * to derive driver specific types.
  184.  */
  185.  
  186. struct ttm_buffer_object {
  187.         /**
  188.          * Members constant at init.
  189.          */
  190.  
  191.         struct ttm_bo_global *glob;
  192.         struct ttm_bo_device *bdev;
  193.         enum ttm_bo_type type;
  194.         void (*destroy) (struct ttm_buffer_object *);
  195.         unsigned long num_pages;
  196.         size_t acc_size;
  197.  
  198.         /**
  199.         * Members not needing protection.
  200.         */
  201.  
  202.         struct kref kref;
  203.         struct kref list_kref;
  204.  
  205.         /**
  206.          * Members protected by the bo::resv::reserved lock.
  207.          */
  208.  
  209.         struct ttm_mem_reg mem;
  210.         struct file *persistent_swap_storage;
  211.         struct ttm_tt *ttm;
  212.         bool evicted;
  213.  
  214.         /**
  215.          * Members protected by the bo::reserved lock only when written to.
  216.          */
  217.  
  218.         atomic_t cpu_writers;
  219.  
  220.         /**
  221.          * Members protected by the bdev::lru_lock.
  222.          */
  223.  
  224.         struct list_head lru;
  225.         struct list_head ddestroy;
  226.         struct list_head swap;
  227.         struct list_head io_reserve_lru;
  228.  
  229.         /**
  230.          * Members protected by struct buffer_object_device::fence_lock
  231.          * In addition, setting sync_obj to anything else
  232.          * than NULL requires bo::reserved to be held. This allows for
  233.          * checking NULL while reserved but not holding the mentioned lock.
  234.          */
  235.  
  236.         void *sync_obj;
  237.         unsigned long priv_flags;
  238.  
  239.         struct drm_vma_offset_node vma_node;
  240.  
  241.         /**
  242.          * Special members that are protected by the reserve lock
  243.          * and the bo::lock when written to. Can be read with
  244.          * either of these locks held.
  245.          */
  246.  
  247.         unsigned long offset;
  248.         uint32_t cur_placement;
  249.  
  250.         struct sg_table *sg;
  251.  
  252.         struct reservation_object *resv;
  253.         struct reservation_object ttm_resv;
  254.         struct mutex wu_mutex;
  255. };
  256.  
  257. /**
  258.  * struct ttm_bo_kmap_obj
  259.  *
  260.  * @virtual: The current kernel virtual address.
  261.  * @page: The page when kmap'ing a single page.
  262.  * @bo_kmap_type: Type of bo_kmap.
  263.  *
  264.  * Object describing a kernel mapping. Since a TTM bo may be located
  265.  * in various memory types with various caching policies, the
  266.  * mapping can either be an ioremap, a vmap, a kmap or part of a
  267.  * premapped region.
  268.  */
  269.  
  270. #define TTM_BO_MAP_IOMEM_MASK 0x80
  271. struct ttm_bo_kmap_obj {
  272.         void *virtual;
  273.         struct page *page;
  274.         enum {
  275.                 ttm_bo_map_iomap        = 1 | TTM_BO_MAP_IOMEM_MASK,
  276.                 ttm_bo_map_vmap         = 2,
  277.                 ttm_bo_map_kmap         = 3,
  278.                 ttm_bo_map_premapped    = 4 | TTM_BO_MAP_IOMEM_MASK,
  279.         } bo_kmap_type;
  280.         struct ttm_buffer_object *bo;
  281. };
  282.  
  283. /**
  284.  * ttm_bo_reference - reference a struct ttm_buffer_object
  285.  *
  286.  * @bo: The buffer object.
  287.  *
  288.  * Returns a refcounted pointer to a buffer object.
  289.  */
  290.  
  291. static inline struct ttm_buffer_object *
  292. ttm_bo_reference(struct ttm_buffer_object *bo)
  293. {
  294.         kref_get(&bo->kref);
  295.         return bo;
  296. }
  297.  
  298. /**
  299.  * ttm_bo_wait - wait for buffer idle.
  300.  *
  301.  * @bo:  The buffer object.
  302.  * @interruptible:  Use interruptible wait.
  303.  * @no_wait:  Return immediately if buffer is busy.
  304.  *
  305.  * This function must be called with the bo::mutex held, and makes
  306.  * sure any previous rendering to the buffer is completed.
  307.  * Note: It might be necessary to block validations before the
  308.  * wait by reserving the buffer.
  309.  * Returns -EBUSY if no_wait is true and the buffer is busy.
  310.  * Returns -ERESTARTSYS if interrupted by a signal.
  311.  */
  312. extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
  313.                        bool interruptible, bool no_wait);
  314. /**
  315.  * ttm_bo_validate
  316.  *
  317.  * @bo: The buffer object.
  318.  * @placement: Proposed placement for the buffer object.
  319.  * @interruptible: Sleep interruptible if sleeping.
  320.  * @no_wait_gpu: Return immediately if the GPU is busy.
  321.  *
  322.  * Changes placement and caching policy of the buffer object
  323.  * according proposed placement.
  324.  * Returns
  325.  * -EINVAL on invalid proposed placement.
  326.  * -ENOMEM on out-of-memory condition.
  327.  * -EBUSY if no_wait is true and buffer busy.
  328.  * -ERESTARTSYS if interrupted by a signal.
  329.  */
  330. extern int ttm_bo_validate(struct ttm_buffer_object *bo,
  331.                                 struct ttm_placement *placement,
  332.                                 bool interruptible,
  333.                                 bool no_wait_gpu);
  334.  
  335. /**
  336.  * ttm_bo_unref
  337.  *
  338.  * @bo: The buffer object.
  339.  *
  340.  * Unreference and clear a pointer to a buffer object.
  341.  */
  342. extern void ttm_bo_unref(struct ttm_buffer_object **bo);
  343.  
  344.  
  345. /**
  346.  * ttm_bo_list_ref_sub
  347.  *
  348.  * @bo: The buffer object.
  349.  * @count: The number of references with which to decrease @bo::list_kref;
  350.  * @never_free: The refcount should not reach zero with this operation.
  351.  *
  352.  * Release @count lru list references to this buffer object.
  353.  */
  354. extern void ttm_bo_list_ref_sub(struct ttm_buffer_object *bo, int count,
  355.                                 bool never_free);
  356.  
  357. /**
  358.  * ttm_bo_add_to_lru
  359.  *
  360.  * @bo: The buffer object.
  361.  *
  362.  * Add this bo to the relevant mem type lru and, if it's backed by
  363.  * system pages (ttms) to the swap list.
  364.  * This function must be called with struct ttm_bo_global::lru_lock held, and
  365.  * is typically called immediately prior to unreserving a bo.
  366.  */
  367. extern void ttm_bo_add_to_lru(struct ttm_buffer_object *bo);
  368.  
  369. /**
  370.  * ttm_bo_del_from_lru
  371.  *
  372.  * @bo: The buffer object.
  373.  *
  374.  * Remove this bo from all lru lists used to lookup and reserve an object.
  375.  * This function must be called with struct ttm_bo_global::lru_lock held,
  376.  * and is usually called just immediately after the bo has been reserved to
  377.  * avoid recursive reservation from lru lists.
  378.  */
  379. extern int ttm_bo_del_from_lru(struct ttm_buffer_object *bo);
  380.  
  381.  
  382. /**
  383.  * ttm_bo_lock_delayed_workqueue
  384.  *
  385.  * Prevent the delayed workqueue from running.
  386.  * Returns
  387.  * True if the workqueue was queued at the time
  388.  */
  389. extern int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev);
  390.  
  391. /**
  392.  * ttm_bo_unlock_delayed_workqueue
  393.  *
  394.  * Allows the delayed workqueue to run.
  395.  */
  396. extern void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev,
  397.                                             int resched);
  398.  
  399. /**
  400.  * ttm_bo_synccpu_write_grab
  401.  *
  402.  * @bo: The buffer object:
  403.  * @no_wait: Return immediately if buffer is busy.
  404.  *
  405.  * Synchronizes a buffer object for CPU RW access. This means
  406.  * command submission that affects the buffer will return -EBUSY
  407.  * until ttm_bo_synccpu_write_release is called.
  408.  *
  409.  * Returns
  410.  * -EBUSY if the buffer is busy and no_wait is true.
  411.  * -ERESTARTSYS if interrupted by a signal.
  412.  */
  413. extern int
  414. ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);
  415.  
  416. /**
  417.  * ttm_bo_synccpu_write_release:
  418.  *
  419.  * @bo : The buffer object.
  420.  *
  421.  * Releases a synccpu lock.
  422.  */
  423. extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);
  424.  
  425. /**
  426.  * ttm_bo_acc_size
  427.  *
  428.  * @bdev: Pointer to a ttm_bo_device struct.
  429.  * @bo_size: size of the buffer object in byte.
  430.  * @struct_size: size of the structure holding buffer object datas
  431.  *
  432.  * Returns size to account for a buffer object
  433.  */
  434. size_t ttm_bo_acc_size(struct ttm_bo_device *bdev,
  435.                        unsigned long bo_size,
  436.                        unsigned struct_size);
  437. size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev,
  438.                            unsigned long bo_size,
  439.                            unsigned struct_size);
  440.  
  441. /**
  442.  * ttm_bo_init
  443.  *
  444.  * @bdev: Pointer to a ttm_bo_device struct.
  445.  * @bo: Pointer to a ttm_buffer_object to be initialized.
  446.  * @size: Requested size of buffer object.
  447.  * @type: Requested type of buffer object.
  448.  * @flags: Initial placement flags.
  449.  * @page_alignment: Data alignment in pages.
  450.  * @interruptible: If needing to sleep to wait for GPU resources,
  451.  * sleep interruptible.
  452.  * @persistent_swap_storage: Usually the swap storage is deleted for buffers
  453.  * pinned in physical memory. If this behaviour is not desired, this member
  454.  * holds a pointer to a persistent shmem object. Typically, this would
  455.  * point to the shmem object backing a GEM object if TTM is used to back a
  456.  * GEM user interface.
  457.  * @acc_size: Accounted size for this object.
  458.  * @destroy: Destroy function. Use NULL for kfree().
  459.  *
  460.  * This function initializes a pre-allocated struct ttm_buffer_object.
  461.  * As this object may be part of a larger structure, this function,
  462.  * together with the @destroy function,
  463.  * enables driver-specific objects derived from a ttm_buffer_object.
  464.  * On successful return, the object kref and list_kref are set to 1.
  465.  * If a failure occurs, the function will call the @destroy function, or
  466.  * kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is
  467.  * illegal and will likely cause memory corruption.
  468.  *
  469.  * Returns
  470.  * -ENOMEM: Out of memory.
  471.  * -EINVAL: Invalid placement flags.
  472.  * -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources.
  473.  */
  474.  
  475. extern int ttm_bo_init(struct ttm_bo_device *bdev,
  476.                         struct ttm_buffer_object *bo,
  477.                         unsigned long size,
  478.                         enum ttm_bo_type type,
  479.                         struct ttm_placement *placement,
  480.                         uint32_t page_alignment,
  481.                         bool interrubtible,
  482.                         struct file *persistent_swap_storage,
  483.                         size_t acc_size,
  484.                         struct sg_table *sg,
  485.                         void (*destroy) (struct ttm_buffer_object *));
  486.  
  487. /**
  488.  * ttm_bo_create
  489.  *
  490.  * @bdev: Pointer to a ttm_bo_device struct.
  491.  * @size: Requested size of buffer object.
  492.  * @type: Requested type of buffer object.
  493.  * @placement: Initial placement.
  494.  * @page_alignment: Data alignment in pages.
  495.  * @interruptible: If needing to sleep while waiting for GPU resources,
  496.  * sleep interruptible.
  497.  * @persistent_swap_storage: Usually the swap storage is deleted for buffers
  498.  * pinned in physical memory. If this behaviour is not desired, this member
  499.  * holds a pointer to a persistent shmem object. Typically, this would
  500.  * point to the shmem object backing a GEM object if TTM is used to back a
  501.  * GEM user interface.
  502.  * @p_bo: On successful completion *p_bo points to the created object.
  503.  *
  504.  * This function allocates a ttm_buffer_object, and then calls ttm_bo_init
  505.  * on that object. The destroy function is set to kfree().
  506.  * Returns
  507.  * -ENOMEM: Out of memory.
  508.  * -EINVAL: Invalid placement flags.
  509.  * -ERESTARTSYS: Interrupted by signal while waiting for resources.
  510.  */
  511.  
  512. extern int ttm_bo_create(struct ttm_bo_device *bdev,
  513.                                 unsigned long size,
  514.                                 enum ttm_bo_type type,
  515.                                 struct ttm_placement *placement,
  516.                                 uint32_t page_alignment,
  517.                                 bool interruptible,
  518.                                 struct file *persistent_swap_storage,
  519.                                 struct ttm_buffer_object **p_bo);
  520.  
  521. /**
  522.  * ttm_bo_check_placement
  523.  *
  524.  * @bo:         the buffer object.
  525.  * @placement:  placements
  526.  *
  527.  * Performs minimal validity checking on an intended change of
  528.  * placement flags.
  529.  * Returns
  530.  * -EINVAL: Intended change is invalid or not allowed.
  531.  */
  532. extern int ttm_bo_check_placement(struct ttm_buffer_object *bo,
  533.                                         struct ttm_placement *placement);
  534.  
  535. /**
  536.  * ttm_bo_init_mm
  537.  *
  538.  * @bdev: Pointer to a ttm_bo_device struct.
  539.  * @mem_type: The memory type.
  540.  * @p_size: size managed area in pages.
  541.  *
  542.  * Initialize a manager for a given memory type.
  543.  * Note: if part of driver firstopen, it must be protected from a
  544.  * potentially racing lastclose.
  545.  * Returns:
  546.  * -EINVAL: invalid size or memory type.
  547.  * -ENOMEM: Not enough memory.
  548.  * May also return driver-specified errors.
  549.  */
  550.  
  551. extern int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
  552.                                 unsigned long p_size);
  553. /**
  554.  * ttm_bo_clean_mm
  555.  *
  556.  * @bdev: Pointer to a ttm_bo_device struct.
  557.  * @mem_type: The memory type.
  558.  *
  559.  * Take down a manager for a given memory type after first walking
  560.  * the LRU list to evict any buffers left alive.
  561.  *
  562.  * Normally, this function is part of lastclose() or unload(), and at that
  563.  * point there shouldn't be any buffers left created by user-space, since
  564.  * there should've been removed by the file descriptor release() method.
  565.  * However, before this function is run, make sure to signal all sync objects,
  566.  * and verify that the delayed delete queue is empty. The driver must also
  567.  * make sure that there are no NO_EVICT buffers present in this memory type
  568.  * when the call is made.
  569.  *
  570.  * If this function is part of a VT switch, the caller must make sure that
  571.  * there are no appications currently validating buffers before this
  572.  * function is called. The caller can do that by first taking the
  573.  * struct ttm_bo_device::ttm_lock in write mode.
  574.  *
  575.  * Returns:
  576.  * -EINVAL: invalid or uninitialized memory type.
  577.  * -EBUSY: There are still buffers left in this memory type.
  578.  */
  579.  
  580. extern int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  581.  
  582. /**
  583.  * ttm_bo_evict_mm
  584.  *
  585.  * @bdev: Pointer to a ttm_bo_device struct.
  586.  * @mem_type: The memory type.
  587.  *
  588.  * Evicts all buffers on the lru list of the memory type.
  589.  * This is normally part of a VT switch or an
  590.  * out-of-memory-space-due-to-fragmentation handler.
  591.  * The caller must make sure that there are no other processes
  592.  * currently validating buffers, and can do that by taking the
  593.  * struct ttm_bo_device::ttm_lock in write mode.
  594.  *
  595.  * Returns:
  596.  * -EINVAL: Invalid or uninitialized memory type.
  597.  * -ERESTARTSYS: The call was interrupted by a signal while waiting to
  598.  * evict a buffer.
  599.  */
  600.  
  601. extern int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  602.  
  603. /**
  604.  * ttm_kmap_obj_virtual
  605.  *
  606.  * @map: A struct ttm_bo_kmap_obj returned from ttm_bo_kmap.
  607.  * @is_iomem: Pointer to an integer that on return indicates 1 if the
  608.  * virtual map is io memory, 0 if normal memory.
  609.  *
  610.  * Returns the virtual address of a buffer object area mapped by ttm_bo_kmap.
  611.  * If *is_iomem is 1 on return, the virtual address points to an io memory area,
  612.  * that should strictly be accessed by the iowriteXX() and similar functions.
  613.  */
  614.  
  615. static inline void *ttm_kmap_obj_virtual(struct ttm_bo_kmap_obj *map,
  616.                                          bool *is_iomem)
  617. {
  618.         *is_iomem = !!(map->bo_kmap_type & TTM_BO_MAP_IOMEM_MASK);
  619.         return map->virtual;
  620. }
  621.  
  622. /**
  623.  * ttm_bo_kmap
  624.  *
  625.  * @bo: The buffer object.
  626.  * @start_page: The first page to map.
  627.  * @num_pages: Number of pages to map.
  628.  * @map: pointer to a struct ttm_bo_kmap_obj representing the map.
  629.  *
  630.  * Sets up a kernel virtual mapping, using ioremap, vmap or kmap to the
  631.  * data in the buffer object. The ttm_kmap_obj_virtual function can then be
  632.  * used to obtain a virtual address to the data.
  633.  *
  634.  * Returns
  635.  * -ENOMEM: Out of memory.
  636.  * -EINVAL: Invalid range.
  637.  */
  638.  
  639. extern int ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page,
  640.                        unsigned long num_pages, struct ttm_bo_kmap_obj *map);
  641.  
  642. /**
  643.  * ttm_bo_kunmap
  644.  *
  645.  * @map: Object describing the map to unmap.
  646.  *
  647.  * Unmaps a kernel map set up by ttm_bo_kmap.
  648.  */
  649.  
  650. extern void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map);
  651.  
  652. /**
  653.  * ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object.
  654.  *
  655.  * @vma:       vma as input from the fbdev mmap method.
  656.  * @bo:        The bo backing the address space. The address space will
  657.  * have the same size as the bo, and start at offset 0.
  658.  *
  659.  * This function is intended to be called by the fbdev mmap method
  660.  * if the fbdev address space is to be backed by a bo.
  661.  */
  662.  
  663. extern int ttm_fbdev_mmap(struct vm_area_struct *vma,
  664.                           struct ttm_buffer_object *bo);
  665.  
  666. /**
  667.  * ttm_bo_mmap - mmap out of the ttm device address space.
  668.  *
  669.  * @filp:      filp as input from the mmap method.
  670.  * @vma:       vma as input from the mmap method.
  671.  * @bdev:      Pointer to the ttm_bo_device with the address space manager.
  672.  *
  673.  * This function is intended to be called by the device mmap method.
  674.  * if the device address space is to be backed by the bo manager.
  675.  */
  676.  
  677. extern int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
  678.                        struct ttm_bo_device *bdev);
  679.  
  680. /**
  681.  * ttm_bo_io
  682.  *
  683.  * @bdev:      Pointer to the struct ttm_bo_device.
  684.  * @filp:      Pointer to the struct file attempting to read / write.
  685.  * @wbuf:      User-space pointer to address of buffer to write. NULL on read.
  686.  * @rbuf:      User-space pointer to address of buffer to read into.
  687.  * Null on write.
  688.  * @count:     Number of bytes to read / write.
  689.  * @f_pos:     Pointer to current file position.
  690.  * @write:     1 for read, 0 for write.
  691.  *
  692.  * This function implements read / write into ttm buffer objects, and is
  693.  * intended to
  694.  * be called from the fops::read and fops::write method.
  695.  * Returns:
  696.  * See man (2) write, man(2) read. In particular,
  697.  * the function may return -ERESTARTSYS if
  698.  * interrupted by a signal.
  699.  */
  700.  
  701. extern ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp,
  702.                          const char __user *wbuf, char __user *rbuf,
  703.                          size_t count, loff_t *f_pos, bool write);
  704.  
  705. extern void ttm_bo_swapout_all(struct ttm_bo_device *bdev);
  706. extern int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo);
  707. #endif
  708.