]>
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 | ||
64 | int drm_sg_alloc( struct inode *inode, struct file *filp, | |
65 | unsigned int cmd, unsigned long arg ) | |
66 | { | |
67 | drm_file_t *priv = filp->private_data; | |
68 | drm_device_t *dev = priv->head->dev; | |
69 | drm_scatter_gather_t __user *argp = (void __user *)arg; | |
70 | drm_scatter_gather_t request; | |
71 | drm_sg_mem_t *entry; | |
72 | unsigned long pages, i, j; | |
73 | ||
74 | DRM_DEBUG( "%s\n", __FUNCTION__ ); | |
75 | ||
76 | if (!drm_core_check_feature(dev, DRIVER_SG)) | |
77 | return -EINVAL; | |
78 | ||
79 | if ( dev->sg ) | |
80 | return -EINVAL; | |
81 | ||
82 | if ( copy_from_user( &request, argp, sizeof(request) ) ) | |
83 | return -EFAULT; | |
84 | ||
85 | entry = drm_alloc( sizeof(*entry), DRM_MEM_SGLISTS ); | |
86 | if ( !entry ) | |
87 | return -ENOMEM; | |
88 | ||
89 | memset( entry, 0, sizeof(*entry) ); | |
90 | ||
91 | pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE; | |
92 | DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages ); | |
93 | ||
94 | entry->pages = pages; | |
95 | entry->pagelist = drm_alloc( pages * sizeof(*entry->pagelist), | |
96 | DRM_MEM_PAGES ); | |
97 | if ( !entry->pagelist ) { | |
98 | drm_free( entry, sizeof(*entry), DRM_MEM_SGLISTS ); | |
99 | return -ENOMEM; | |
100 | } | |
101 | ||
102 | memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist)); | |
103 | ||
104 | entry->busaddr = drm_alloc( pages * sizeof(*entry->busaddr), | |
105 | DRM_MEM_PAGES ); | |
106 | if ( !entry->busaddr ) { | |
107 | drm_free( entry->pagelist, | |
108 | entry->pages * sizeof(*entry->pagelist), | |
109 | DRM_MEM_PAGES ); | |
110 | drm_free( entry, | |
111 | sizeof(*entry), | |
112 | DRM_MEM_SGLISTS ); | |
113 | return -ENOMEM; | |
114 | } | |
115 | memset( (void *)entry->busaddr, 0, pages * sizeof(*entry->busaddr) ); | |
116 | ||
117 | entry->virtual = vmalloc_32( pages << PAGE_SHIFT ); | |
118 | if ( !entry->virtual ) { | |
119 | drm_free( entry->busaddr, | |
120 | entry->pages * sizeof(*entry->busaddr), | |
121 | DRM_MEM_PAGES ); | |
122 | drm_free( entry->pagelist, | |
123 | entry->pages * sizeof(*entry->pagelist), | |
124 | DRM_MEM_PAGES ); | |
125 | drm_free( entry, | |
126 | sizeof(*entry), | |
127 | DRM_MEM_SGLISTS ); | |
128 | return -ENOMEM; | |
129 | } | |
130 | ||
131 | /* This also forces the mapping of COW pages, so our page list | |
132 | * will be valid. Please don't remove it... | |
133 | */ | |
134 | memset( entry->virtual, 0, pages << PAGE_SHIFT ); | |
135 | ||
136 | entry->handle = (unsigned long)entry->virtual; | |
137 | ||
138 | DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle ); | |
139 | DRM_DEBUG( "sg alloc virtual = %p\n", entry->virtual ); | |
140 | ||
141 | for ( i = entry->handle, j = 0 ; j < pages ; i += PAGE_SIZE, j++ ) { | |
142 | entry->pagelist[j] = vmalloc_to_page((void *)i); | |
143 | if (!entry->pagelist[j]) | |
144 | goto failed; | |
145 | SetPageReserved(entry->pagelist[j]); | |
146 | } | |
147 | ||
148 | request.handle = entry->handle; | |
149 | ||
150 | if ( copy_to_user( argp, &request, sizeof(request) ) ) { | |
151 | drm_sg_cleanup( entry ); | |
152 | return -EFAULT; | |
153 | } | |
154 | ||
155 | dev->sg = entry; | |
156 | ||
157 | #if DEBUG_SCATTER | |
158 | /* Verify that each page points to its virtual address, and vice | |
159 | * versa. | |
160 | */ | |
161 | { | |
162 | int error = 0; | |
163 | ||
164 | for ( i = 0 ; i < pages ; i++ ) { | |
165 | unsigned long *tmp; | |
166 | ||
167 | tmp = page_address( entry->pagelist[i] ); | |
168 | for ( j = 0 ; | |
169 | j < PAGE_SIZE / sizeof(unsigned long) ; | |
170 | j++, tmp++ ) { | |
171 | *tmp = 0xcafebabe; | |
172 | } | |
173 | tmp = (unsigned long *)((u8 *)entry->virtual + | |
174 | (PAGE_SIZE * i)); | |
175 | for( j = 0 ; | |
176 | j < PAGE_SIZE / sizeof(unsigned long) ; | |
177 | j++, tmp++ ) { | |
178 | if ( *tmp != 0xcafebabe && error == 0 ) { | |
179 | error = 1; | |
180 | DRM_ERROR( "Scatter allocation error, " | |
181 | "pagelist does not match " | |
182 | "virtual mapping\n" ); | |
183 | } | |
184 | } | |
185 | tmp = page_address( entry->pagelist[i] ); | |
186 | for(j = 0 ; | |
187 | j < PAGE_SIZE / sizeof(unsigned long) ; | |
188 | j++, tmp++) { | |
189 | *tmp = 0; | |
190 | } | |
191 | } | |
192 | if (error == 0) | |
193 | DRM_ERROR( "Scatter allocation matches pagelist\n" ); | |
194 | } | |
195 | #endif | |
196 | ||
197 | return 0; | |
198 | ||
199 | failed: | |
200 | drm_sg_cleanup( entry ); | |
201 | return -ENOMEM; | |
202 | } | |
203 | ||
204 | int drm_sg_free( struct inode *inode, struct file *filp, | |
205 | unsigned int cmd, unsigned long arg ) | |
206 | { | |
207 | drm_file_t *priv = filp->private_data; | |
208 | drm_device_t *dev = priv->head->dev; | |
209 | drm_scatter_gather_t request; | |
210 | drm_sg_mem_t *entry; | |
211 | ||
212 | if (!drm_core_check_feature(dev, DRIVER_SG)) | |
213 | return -EINVAL; | |
214 | ||
215 | if ( copy_from_user( &request, | |
216 | (drm_scatter_gather_t __user *)arg, | |
217 | sizeof(request) ) ) | |
218 | return -EFAULT; | |
219 | ||
220 | entry = dev->sg; | |
221 | dev->sg = NULL; | |
222 | ||
223 | if ( !entry || entry->handle != request.handle ) | |
224 | return -EINVAL; | |
225 | ||
226 | DRM_DEBUG( "sg free virtual = %p\n", entry->virtual ); | |
227 | ||
228 | drm_sg_cleanup( entry ); | |
229 | ||
230 | return 0; | |
231 | } |