Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /** |
2 | * \file drm_scatter.h | |
3 | * IOCTLs to manage scatter/gather memory | |
4 | * | |
5 | * \author Gareth Hughes <gareth@valinux.com> | |
6 | */ | |
7 | ||
8 | /* | |
9 | * Created: Mon Dec 18 23:20:54 2000 by gareth@valinux.com | |
10 | * | |
11 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. | |
12 | * All Rights Reserved. | |
13 | * | |
14 | * Permission is hereby granted, free of charge, to any person obtaining a | |
15 | * copy of this software and associated documentation files (the "Software"), | |
16 | * to deal in the Software without restriction, including without limitation | |
17 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
18 | * and/or sell copies of the Software, and to permit persons to whom the | |
19 | * Software is furnished to do so, subject to the following conditions: | |
20 | * | |
21 | * The above copyright notice and this permission notice (including the next | |
22 | * paragraph) shall be included in all copies or substantial portions of the | |
23 | * Software. | |
24 | * | |
25 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
26 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
27 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
28 | * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
29 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
30 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |
31 | * DEALINGS IN THE SOFTWARE. | |
32 | */ | |
33 | ||
34 | #include <linux/config.h> | |
35 | #include <linux/vmalloc.h> | |
36 | #include "drmP.h" | |
37 | ||
38 | #define DEBUG_SCATTER 0 | |
39 | ||
40 | void drm_sg_cleanup( drm_sg_mem_t *entry ) | |
41 | { | |
42 | struct page *page; | |
43 | int i; | |
44 | ||
45 | for ( i = 0 ; i < entry->pages ; i++ ) { | |
46 | page = entry->pagelist[i]; | |
47 | if ( page ) | |
48 | ClearPageReserved( page ); | |
49 | } | |
50 | ||
51 | vfree( entry->virtual ); | |
52 | ||
53 | drm_free( entry->busaddr, | |
54 | entry->pages * sizeof(*entry->busaddr), | |
55 | DRM_MEM_PAGES ); | |
56 | drm_free( entry->pagelist, | |
57 | entry->pages * sizeof(*entry->pagelist), | |
58 | DRM_MEM_PAGES ); | |
59 | drm_free( entry, | |
60 | sizeof(*entry), | |
61 | DRM_MEM_SGLISTS ); | |
62 | } | |
63 | ||
d1f2b55a DA |
64 | #ifdef _LP64 |
65 | # define ScatterHandle(x) (unsigned int)((x >> 32) + (x & ((1L << 32) - 1))) | |
66 | #else | |
67 | # define ScatterHandle(x) (unsigned int)(x) | |
68 | #endif | |
69 | ||
1da177e4 LT |
70 | int drm_sg_alloc( struct inode *inode, struct file *filp, |
71 | unsigned int cmd, unsigned long arg ) | |
72 | { | |
73 | drm_file_t *priv = filp->private_data; | |
74 | drm_device_t *dev = priv->head->dev; | |
75 | drm_scatter_gather_t __user *argp = (void __user *)arg; | |
76 | drm_scatter_gather_t request; | |
77 | drm_sg_mem_t *entry; | |
78 | unsigned long pages, i, j; | |
79 | ||
80 | DRM_DEBUG( "%s\n", __FUNCTION__ ); | |
81 | ||
82 | if (!drm_core_check_feature(dev, DRIVER_SG)) | |
83 | return -EINVAL; | |
84 | ||
85 | if ( dev->sg ) | |
86 | return -EINVAL; | |
87 | ||
88 | if ( copy_from_user( &request, argp, sizeof(request) ) ) | |
89 | return -EFAULT; | |
90 | ||
91 | entry = drm_alloc( sizeof(*entry), DRM_MEM_SGLISTS ); | |
92 | if ( !entry ) | |
93 | return -ENOMEM; | |
94 | ||
95 | memset( entry, 0, sizeof(*entry) ); | |
96 | ||
97 | pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE; | |
98 | DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages ); | |
99 | ||
100 | entry->pages = pages; | |
101 | entry->pagelist = drm_alloc( pages * sizeof(*entry->pagelist), | |
102 | DRM_MEM_PAGES ); | |
103 | if ( !entry->pagelist ) { | |
104 | drm_free( entry, sizeof(*entry), DRM_MEM_SGLISTS ); | |
105 | return -ENOMEM; | |
106 | } | |
107 | ||
108 | memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist)); | |
109 | ||
110 | entry->busaddr = drm_alloc( pages * sizeof(*entry->busaddr), | |
111 | DRM_MEM_PAGES ); | |
112 | if ( !entry->busaddr ) { | |
113 | drm_free( entry->pagelist, | |
114 | entry->pages * sizeof(*entry->pagelist), | |
115 | DRM_MEM_PAGES ); | |
116 | drm_free( entry, | |
117 | sizeof(*entry), | |
118 | DRM_MEM_SGLISTS ); | |
119 | return -ENOMEM; | |
120 | } | |
121 | memset( (void *)entry->busaddr, 0, pages * sizeof(*entry->busaddr) ); | |
122 | ||
123 | entry->virtual = vmalloc_32( pages << PAGE_SHIFT ); | |
124 | if ( !entry->virtual ) { | |
125 | drm_free( entry->busaddr, | |
126 | entry->pages * sizeof(*entry->busaddr), | |
127 | DRM_MEM_PAGES ); | |
128 | drm_free( entry->pagelist, | |
129 | entry->pages * sizeof(*entry->pagelist), | |
130 | DRM_MEM_PAGES ); | |
131 | drm_free( entry, | |
132 | sizeof(*entry), | |
133 | DRM_MEM_SGLISTS ); | |
134 | return -ENOMEM; | |
135 | } | |
136 | ||
137 | /* This also forces the mapping of COW pages, so our page list | |
138 | * will be valid. Please don't remove it... | |
139 | */ | |
140 | memset( entry->virtual, 0, pages << PAGE_SHIFT ); | |
141 | ||
d1f2b55a | 142 | entry->handle = ScatterHandle((unsigned long)entry->virtual); |
1da177e4 LT |
143 | |
144 | DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle ); | |
145 | DRM_DEBUG( "sg alloc virtual = %p\n", entry->virtual ); | |
146 | ||
d1f2b55a DA |
147 | for (i = (unsigned long)entry->virtual, j = 0; j < pages; |
148 | i += PAGE_SIZE, j++) { | |
1da177e4 LT |
149 | entry->pagelist[j] = vmalloc_to_page((void *)i); |
150 | if (!entry->pagelist[j]) | |
151 | goto failed; | |
152 | SetPageReserved(entry->pagelist[j]); | |
153 | } | |
154 | ||
155 | request.handle = entry->handle; | |
156 | ||
157 | if ( copy_to_user( argp, &request, sizeof(request) ) ) { | |
158 | drm_sg_cleanup( entry ); | |
159 | return -EFAULT; | |
160 | } | |
161 | ||
162 | dev->sg = entry; | |
163 | ||
164 | #if DEBUG_SCATTER | |
165 | /* Verify that each page points to its virtual address, and vice | |
166 | * versa. | |
167 | */ | |
168 | { | |
169 | int error = 0; | |
170 | ||
171 | for ( i = 0 ; i < pages ; i++ ) { | |
172 | unsigned long *tmp; | |
173 | ||
174 | tmp = page_address( entry->pagelist[i] ); | |
175 | for ( j = 0 ; | |
176 | j < PAGE_SIZE / sizeof(unsigned long) ; | |
177 | j++, tmp++ ) { | |
178 | *tmp = 0xcafebabe; | |
179 | } | |
180 | tmp = (unsigned long *)((u8 *)entry->virtual + | |
181 | (PAGE_SIZE * i)); | |
182 | for( j = 0 ; | |
183 | j < PAGE_SIZE / sizeof(unsigned long) ; | |
184 | j++, tmp++ ) { | |
185 | if ( *tmp != 0xcafebabe && error == 0 ) { | |
186 | error = 1; | |
187 | DRM_ERROR( "Scatter allocation error, " | |
188 | "pagelist does not match " | |
189 | "virtual mapping\n" ); | |
190 | } | |
191 | } | |
192 | tmp = page_address( entry->pagelist[i] ); | |
193 | for(j = 0 ; | |
194 | j < PAGE_SIZE / sizeof(unsigned long) ; | |
195 | j++, tmp++) { | |
196 | *tmp = 0; | |
197 | } | |
198 | } | |
199 | if (error == 0) | |
200 | DRM_ERROR( "Scatter allocation matches pagelist\n" ); | |
201 | } | |
202 | #endif | |
203 | ||
204 | return 0; | |
205 | ||
206 | failed: | |
207 | drm_sg_cleanup( entry ); | |
208 | return -ENOMEM; | |
209 | } | |
210 | ||
211 | int drm_sg_free( struct inode *inode, struct file *filp, | |
212 | unsigned int cmd, unsigned long arg ) | |
213 | { | |
214 | drm_file_t *priv = filp->private_data; | |
215 | drm_device_t *dev = priv->head->dev; | |
216 | drm_scatter_gather_t request; | |
217 | drm_sg_mem_t *entry; | |
218 | ||
219 | if (!drm_core_check_feature(dev, DRIVER_SG)) | |
220 | return -EINVAL; | |
221 | ||
222 | if ( copy_from_user( &request, | |
223 | (drm_scatter_gather_t __user *)arg, | |
224 | sizeof(request) ) ) | |
225 | return -EFAULT; | |
226 | ||
227 | entry = dev->sg; | |
228 | dev->sg = NULL; | |
229 | ||
230 | if ( !entry || entry->handle != request.handle ) | |
231 | return -EINVAL; | |
232 | ||
233 | DRM_DEBUG( "sg free virtual = %p\n", entry->virtual ); | |
234 | ||
235 | drm_sg_cleanup( entry ); | |
236 | ||
237 | return 0; | |
238 | } |