diff options
Diffstat (limited to 'include')
-rw-r--r-- | include/drm/drm_buffer.h | 148 |
1 files changed, 148 insertions, 0 deletions
diff --git a/include/drm/drm_buffer.h b/include/drm/drm_buffer.h new file mode 100644 index 000000000000..322dbff3f861 --- /dev/null +++ b/include/drm/drm_buffer.h | |||
@@ -0,0 +1,148 @@ | |||
1 | /************************************************************************** | ||
2 | * | ||
3 | * Copyright 2010 Pauli Nieminen. | ||
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 | /* | ||
29 | * Multipart buffer for coping data which is larger than the page size. | ||
30 | * | ||
31 | * Authors: | ||
32 | * Pauli Nieminen <suokkos-at-gmail-dot-com> | ||
33 | */ | ||
34 | |||
35 | #ifndef _DRM_BUFFER_H_ | ||
36 | #define _DRM_BUFFER_H_ | ||
37 | |||
38 | #include "drmP.h" | ||
39 | |||
40 | struct drm_buffer { | ||
41 | int iterator; | ||
42 | int size; | ||
43 | char *data[]; | ||
44 | }; | ||
45 | |||
46 | |||
47 | /** | ||
48 | * Return the index of page that buffer is currently pointing at. | ||
49 | */ | ||
50 | static inline int drm_buffer_page(struct drm_buffer *buf) | ||
51 | { | ||
52 | return buf->iterator / PAGE_SIZE; | ||
53 | } | ||
54 | /** | ||
55 | * Return the index of the current byte in the page | ||
56 | */ | ||
57 | static inline int drm_buffer_index(struct drm_buffer *buf) | ||
58 | { | ||
59 | return buf->iterator & (PAGE_SIZE - 1); | ||
60 | } | ||
61 | /** | ||
62 | * Return number of bytes that is left to process | ||
63 | */ | ||
64 | static inline int drm_buffer_unprocessed(struct drm_buffer *buf) | ||
65 | { | ||
66 | return buf->size - buf->iterator; | ||
67 | } | ||
68 | |||
69 | /** | ||
70 | * Advance the buffer iterator number of bytes that is given. | ||
71 | */ | ||
72 | static inline void drm_buffer_advance(struct drm_buffer *buf, int bytes) | ||
73 | { | ||
74 | buf->iterator += bytes; | ||
75 | } | ||
76 | |||
77 | /** | ||
78 | * Allocate the drm buffer object. | ||
79 | * | ||
80 | * buf: A pointer to a pointer where the object is stored. | ||
81 | * size: The number of bytes to allocate. | ||
82 | */ | ||
83 | extern int drm_buffer_alloc(struct drm_buffer **buf, int size); | ||
84 | |||
85 | /** | ||
86 | * Copy the user data to the begin of the buffer and reset the processing | ||
87 | * iterator. | ||
88 | * | ||
89 | * user_data: A pointer the data that is copied to the buffer. | ||
90 | * size: The Number of bytes to copy. | ||
91 | */ | ||
92 | extern int drm_buffer_copy_from_user(struct drm_buffer *buf, | ||
93 | void __user *user_data, int size); | ||
94 | |||
95 | /** | ||
96 | * Free the drm buffer object | ||
97 | */ | ||
98 | extern void drm_buffer_free(struct drm_buffer *buf); | ||
99 | |||
100 | /** | ||
101 | * Read an object from buffer that may be split to multiple parts. If object | ||
102 | * is not split function just returns the pointer to object in buffer. But in | ||
103 | * case of split object data is copied to given stack object that is suplied | ||
104 | * by caller. | ||
105 | * | ||
106 | * The processing location of the buffer is also advanced to the next byte | ||
107 | * after the object. | ||
108 | * | ||
109 | * objsize: The size of the objet in bytes. | ||
110 | * stack_obj: A pointer to a memory location where object can be copied. | ||
111 | */ | ||
112 | extern void *drm_buffer_read_object(struct drm_buffer *buf, | ||
113 | int objsize, void *stack_obj); | ||
114 | |||
115 | /** | ||
116 | * Returns the pointer to the dword which is offset number of elements from the | ||
117 | * current processing location. | ||
118 | * | ||
119 | * Caller must make sure that dword is not split in the buffer. This | ||
120 | * requirement is easily met if all the sizes of objects in buffer are | ||
121 | * multiples of dword and PAGE_SIZE is multiple dword. | ||
122 | * | ||
123 | * Call to this function doesn't change the processing location. | ||
124 | * | ||
125 | * offset: The index of the dword relative to the internat iterator. | ||
126 | */ | ||
127 | static inline void *drm_buffer_pointer_to_dword(struct drm_buffer *buffer, | ||
128 | int offset) | ||
129 | { | ||
130 | int iter = buffer->iterator + offset * 4; | ||
131 | return &buffer->data[iter / PAGE_SIZE][iter & (PAGE_SIZE - 1)]; | ||
132 | } | ||
133 | /** | ||
134 | * Returns the pointer to the dword which is offset number of elements from | ||
135 | * the current processing location. | ||
136 | * | ||
137 | * Call to this function doesn't change the processing location. | ||
138 | * | ||
139 | * offset: The index of the byte relative to the internat iterator. | ||
140 | */ | ||
141 | static inline void *drm_buffer_pointer_to_byte(struct drm_buffer *buffer, | ||
142 | int offset) | ||
143 | { | ||
144 | int iter = buffer->iterator + offset; | ||
145 | return &buffer->data[iter / PAGE_SIZE][iter & (PAGE_SIZE - 1)]; | ||
146 | } | ||
147 | |||
148 | #endif | ||