ion.h 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
  1. /*
  2. * drivers/staging/android/uapi/ion.h
  3. *
  4. * Copyright (C) 2011 Google, Inc.
  5. *
  6. * This software is licensed under the terms of the GNU General Public
  7. * License version 2, as published by the Free Software Foundation, and
  8. * may be copied, distributed, and modified under those terms.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. */
  16. #ifndef _UAPI_LINUX_ION_H
  17. #define _UAPI_LINUX_ION_H
  18. #include <linux/ioctl.h>
  19. #include <linux/types.h>
  20. typedef int ion_user_handle_t;
  21. /**
  22. * enum ion_heap_types - list of all possible types of heaps
  23. * @ION_HEAP_TYPE_SYSTEM: memory allocated via vmalloc
  24. * @ION_HEAP_TYPE_SYSTEM_CONTIG: memory allocated via kmalloc
  25. * @ION_HEAP_TYPE_CARVEOUT: memory allocated from a prereserved
  26. * carveout heap, allocations are physically
  27. * contiguous
  28. * @ION_HEAP_TYPE_DMA: memory allocated via DMA API
  29. * @ION_NUM_HEAPS: helper for iterating over heaps, a bit mask
  30. * is used to identify the heaps, so only 32
  31. * total heap types are supported
  32. */
  33. enum ion_heap_type {
  34. ION_HEAP_TYPE_SYSTEM,
  35. ION_HEAP_TYPE_SYSTEM_CONTIG,
  36. ION_HEAP_TYPE_CARVEOUT,
  37. ION_HEAP_TYPE_CHUNK,
  38. ION_HEAP_TYPE_DMA,
  39. ION_HEAP_TYPE_CUSTOM, /*
  40. * must be last so device specific heaps always
  41. * are at the end of this enum
  42. */
  43. ION_NUM_HEAPS = 16,
  44. };
  45. #define ION_HEAP_SYSTEM_MASK (1 << ION_HEAP_TYPE_SYSTEM)
  46. #define ION_HEAP_SYSTEM_CONTIG_MASK (1 << ION_HEAP_TYPE_SYSTEM_CONTIG)
  47. #define ION_HEAP_CARVEOUT_MASK (1 << ION_HEAP_TYPE_CARVEOUT)
  48. #define ION_HEAP_TYPE_DMA_MASK (1 << ION_HEAP_TYPE_DMA)
  49. #define ION_NUM_HEAP_IDS (sizeof(unsigned int) * 8)
  50. /**
  51. * allocation flags - the lower 16 bits are used by core ion, the upper 16
  52. * bits are reserved for use by the heaps themselves.
  53. */
  54. #define ION_FLAG_CACHED 1 /*
  55. * mappings of this buffer should be
  56. * cached, ion will do cache
  57. * maintenance when the buffer is
  58. * mapped for dma
  59. */
  60. #define ION_FLAG_CACHED_NEEDS_SYNC 2 /*
  61. * mappings of this buffer will created
  62. * at mmap time, if this is set
  63. * caches must be managed
  64. * manually
  65. */
  66. /**
  67. * DOC: Ion Userspace API
  68. *
  69. * create a client by opening /dev/ion
  70. * most operations handled via following ioctls
  71. *
  72. */
  73. /**
  74. * struct ion_allocation_data - metadata passed from userspace for allocations
  75. * @len: size of the allocation
  76. * @align: required alignment of the allocation
  77. * @heap_id_mask: mask of heap ids to allocate from
  78. * @flags: flags passed to heap
  79. * @handle: pointer that will be populated with a cookie to use to
  80. * refer to this allocation
  81. *
  82. * Provided by userspace as an argument to the ioctl
  83. */
  84. struct ion_allocation_data {
  85. size_t len;
  86. size_t align;
  87. unsigned int heap_id_mask;
  88. unsigned int flags;
  89. ion_user_handle_t handle;
  90. };
  91. /**
  92. * struct ion_fd_data - metadata passed to/from userspace for a handle/fd pair
  93. * @handle: a handle
  94. * @fd: a file descriptor representing that handle
  95. *
  96. * For ION_IOC_SHARE or ION_IOC_MAP userspace populates the handle field with
  97. * the handle returned from ion alloc, and the kernel returns the file
  98. * descriptor to share or map in the fd field. For ION_IOC_IMPORT, userspace
  99. * provides the file descriptor and the kernel returns the handle.
  100. */
  101. struct ion_fd_data {
  102. ion_user_handle_t handle;
  103. int fd;
  104. };
  105. /**
  106. * struct ion_handle_data - a handle passed to/from the kernel
  107. * @handle: a handle
  108. */
  109. struct ion_handle_data {
  110. ion_user_handle_t handle;
  111. };
  112. /**
  113. * struct ion_custom_data - metadata passed to/from userspace for a custom ioctl
  114. * @cmd: the custom ioctl function to call
  115. * @arg: additional data to pass to the custom ioctl, typically a user
  116. * pointer to a predefined structure
  117. *
  118. * This works just like the regular cmd and arg fields of an ioctl.
  119. */
  120. struct ion_custom_data {
  121. unsigned int cmd;
  122. unsigned long arg;
  123. };
  124. #define ION_IOC_MAGIC 'I'
  125. /**
  126. * DOC: ION_IOC_ALLOC - allocate memory
  127. *
  128. * Takes an ion_allocation_data struct and returns it with the handle field
  129. * populated with the opaque handle for the allocation.
  130. */
  131. #define ION_IOC_ALLOC _IOWR(ION_IOC_MAGIC, 0, \
  132. struct ion_allocation_data)
  133. /**
  134. * DOC: ION_IOC_FREE - free memory
  135. *
  136. * Takes an ion_handle_data struct and frees the handle.
  137. */
  138. #define ION_IOC_FREE _IOWR(ION_IOC_MAGIC, 1, struct ion_handle_data)
  139. /**
  140. * DOC: ION_IOC_MAP - get a file descriptor to mmap
  141. *
  142. * Takes an ion_fd_data struct with the handle field populated with a valid
  143. * opaque handle. Returns the struct with the fd field set to a file
  144. * descriptor open in the current address space. This file descriptor
  145. * can then be used as an argument to mmap.
  146. */
  147. #define ION_IOC_MAP _IOWR(ION_IOC_MAGIC, 2, struct ion_fd_data)
  148. /**
  149. * DOC: ION_IOC_SHARE - creates a file descriptor to use to share an allocation
  150. *
  151. * Takes an ion_fd_data struct with the handle field populated with a valid
  152. * opaque handle. Returns the struct with the fd field set to a file
  153. * descriptor open in the current address space. This file descriptor
  154. * can then be passed to another process. The corresponding opaque handle can
  155. * be retrieved via ION_IOC_IMPORT.
  156. */
  157. #define ION_IOC_SHARE _IOWR(ION_IOC_MAGIC, 4, struct ion_fd_data)
  158. /**
  159. * DOC: ION_IOC_IMPORT - imports a shared file descriptor
  160. *
  161. * Takes an ion_fd_data struct with the fd field populated with a valid file
  162. * descriptor obtained from ION_IOC_SHARE and returns the struct with the handle
  163. * filed set to the corresponding opaque handle.
  164. */
  165. #define ION_IOC_IMPORT _IOWR(ION_IOC_MAGIC, 5, struct ion_fd_data)
  166. /**
  167. * DOC: ION_IOC_SYNC - syncs a shared file descriptors to memory
  168. *
  169. * Deprecated in favor of using the dma_buf api's correctly (syncing
  170. * will happen automatically when the buffer is mapped to a device).
  171. * If necessary should be used after touching a cached buffer from the cpu,
  172. * this will make the buffer in memory coherent.
  173. */
  174. #define ION_IOC_SYNC _IOWR(ION_IOC_MAGIC, 7, struct ion_fd_data)
  175. /**
  176. * DOC: ION_IOC_CUSTOM - call architecture specific ion ioctl
  177. *
  178. * Takes the argument of the architecture specific ioctl to call and
  179. * passes appropriate userdata for that ioctl
  180. */
  181. #define ION_IOC_CUSTOM _IOWR(ION_IOC_MAGIC, 6, struct ion_custom_data)
  182. #endif /* _UAPI_LINUX_ION_H */