]>
Commit | Line | Data |
---|---|---|
bc5f4523 | 1 | /* r128_cce.c -- ATI Rage 128 driver -*- linux-c -*- |
1da177e4 | 2 | * Created: Wed Apr 5 19:24:19 2000 by kevin@precisioninsight.com |
f26c473c DA |
3 | */ |
4 | /* | |
1da177e4 LT |
5 | * Copyright 2000 Precision Insight, Inc., Cedar Park, Texas. |
6 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. | |
7 | * All Rights Reserved. | |
8 | * | |
9 | * Permission is hereby granted, free of charge, to any person obtaining a | |
10 | * copy of this software and associated documentation files (the "Software"), | |
11 | * to deal in the Software without restriction, including without limitation | |
12 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
13 | * and/or sell copies of the Software, and to permit persons to whom the | |
14 | * Software is furnished to do so, subject to the following conditions: | |
15 | * | |
16 | * The above copyright notice and this permission notice (including the next | |
17 | * paragraph) shall be included in all copies or substantial portions of the | |
18 | * Software. | |
19 | * | |
20 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
21 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
22 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
23 | * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
24 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
25 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |
26 | * DEALINGS IN THE SOFTWARE. | |
27 | * | |
28 | * Authors: | |
29 | * Gareth Hughes <gareth@valinux.com> | |
30 | */ | |
31 | ||
32 | #include "drmP.h" | |
33 | #include "drm.h" | |
34 | #include "r128_drm.h" | |
35 | #include "r128_drv.h" | |
36 | ||
37 | #define R128_FIFO_DEBUG 0 | |
38 | ||
39 | /* CCE microcode (from ATI) */ | |
40 | static u32 r128_cce_microcode[] = { | |
41 | 0, 276838400, 0, 268449792, 2, 142, 2, 145, 0, 1076765731, 0, | |
42 | 1617039951, 0, 774592877, 0, 1987540286, 0, 2307490946U, 0, | |
43 | 599558925, 0, 589505315, 0, 596487092, 0, 589505315, 1, | |
44 | 11544576, 1, 206848, 1, 311296, 1, 198656, 2, 912273422, 11, | |
45 | 262144, 0, 0, 1, 33559837, 1, 7438, 1, 14809, 1, 6615, 12, 28, | |
46 | 1, 6614, 12, 28, 2, 23, 11, 18874368, 0, 16790922, 1, 409600, 9, | |
47 | 30, 1, 147854772, 16, 420483072, 3, 8192, 0, 10240, 1, 198656, | |
48 | 1, 15630, 1, 51200, 10, 34858, 9, 42, 1, 33559823, 2, 10276, 1, | |
49 | 15717, 1, 15718, 2, 43, 1, 15936948, 1, 570480831, 1, 14715071, | |
50 | 12, 322123831, 1, 33953125, 12, 55, 1, 33559908, 1, 15718, 2, | |
51 | 46, 4, 2099258, 1, 526336, 1, 442623, 4, 4194365, 1, 509952, 1, | |
52 | 459007, 3, 0, 12, 92, 2, 46, 12, 176, 1, 15734, 1, 206848, 1, | |
53 | 18432, 1, 133120, 1, 100670734, 1, 149504, 1, 165888, 1, | |
54 | 15975928, 1, 1048576, 6, 3145806, 1, 15715, 16, 2150645232U, 2, | |
55 | 268449859, 2, 10307, 12, 176, 1, 15734, 1, 15735, 1, 15630, 1, | |
56 | 15631, 1, 5253120, 6, 3145810, 16, 2150645232U, 1, 15864, 2, 82, | |
57 | 1, 343310, 1, 1064207, 2, 3145813, 1, 15728, 1, 7817, 1, 15729, | |
58 | 3, 15730, 12, 92, 2, 98, 1, 16168, 1, 16167, 1, 16002, 1, 16008, | |
59 | 1, 15974, 1, 15975, 1, 15990, 1, 15976, 1, 15977, 1, 15980, 0, | |
60 | 15981, 1, 10240, 1, 5253120, 1, 15720, 1, 198656, 6, 110, 1, | |
61 | 180224, 1, 103824738, 2, 112, 2, 3145839, 0, 536885440, 1, | |
62 | 114880, 14, 125, 12, 206975, 1, 33559995, 12, 198784, 0, | |
63 | 33570236, 1, 15803, 0, 15804, 3, 294912, 1, 294912, 3, 442370, | |
64 | 1, 11544576, 0, 811612160, 1, 12593152, 1, 11536384, 1, | |
65 | 14024704, 7, 310382726, 0, 10240, 1, 14796, 1, 14797, 1, 14793, | |
66 | 1, 14794, 0, 14795, 1, 268679168, 1, 9437184, 1, 268449792, 1, | |
67 | 198656, 1, 9452827, 1, 1075854602, 1, 1075854603, 1, 557056, 1, | |
68 | 114880, 14, 159, 12, 198784, 1, 1109409213, 12, 198783, 1, | |
69 | 1107312059, 12, 198784, 1, 1109409212, 2, 162, 1, 1075854781, 1, | |
70 | 1073757627, 1, 1075854780, 1, 540672, 1, 10485760, 6, 3145894, | |
71 | 16, 274741248, 9, 168, 3, 4194304, 3, 4209949, 0, 0, 0, 256, 14, | |
72 | 174, 1, 114857, 1, 33560007, 12, 176, 0, 10240, 1, 114858, 1, | |
73 | 33560018, 1, 114857, 3, 33560007, 1, 16008, 1, 114874, 1, | |
74 | 33560360, 1, 114875, 1, 33560154, 0, 15963, 0, 256, 0, 4096, 1, | |
75 | 409611, 9, 188, 0, 10240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
76 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
77 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
78 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
79 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
80 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
81 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 | |
82 | }; | |
83 | ||
eddca551 | 84 | static int R128_READ_PLL(struct drm_device * dev, int addr) |
1da177e4 LT |
85 | { |
86 | drm_r128_private_t *dev_priv = dev->dev_private; | |
87 | ||
88 | R128_WRITE8(R128_CLOCK_CNTL_INDEX, addr & 0x1f); | |
89 | return R128_READ(R128_CLOCK_CNTL_DATA); | |
90 | } | |
91 | ||
92 | #if R128_FIFO_DEBUG | |
b5e89ed5 | 93 | static void r128_status(drm_r128_private_t * dev_priv) |
1da177e4 | 94 | { |
b5e89ed5 DA |
95 | printk("GUI_STAT = 0x%08x\n", |
96 | (unsigned int)R128_READ(R128_GUI_STAT)); | |
97 | printk("PM4_STAT = 0x%08x\n", | |
98 | (unsigned int)R128_READ(R128_PM4_STAT)); | |
99 | printk("PM4_BUFFER_DL_WPTR = 0x%08x\n", | |
100 | (unsigned int)R128_READ(R128_PM4_BUFFER_DL_WPTR)); | |
101 | printk("PM4_BUFFER_DL_RPTR = 0x%08x\n", | |
102 | (unsigned int)R128_READ(R128_PM4_BUFFER_DL_RPTR)); | |
103 | printk("PM4_MICRO_CNTL = 0x%08x\n", | |
104 | (unsigned int)R128_READ(R128_PM4_MICRO_CNTL)); | |
105 | printk("PM4_BUFFER_CNTL = 0x%08x\n", | |
106 | (unsigned int)R128_READ(R128_PM4_BUFFER_CNTL)); | |
1da177e4 LT |
107 | } |
108 | #endif | |
109 | ||
1da177e4 LT |
110 | /* ================================================================ |
111 | * Engine, FIFO control | |
112 | */ | |
113 | ||
b5e89ed5 | 114 | static int r128_do_pixcache_flush(drm_r128_private_t * dev_priv) |
1da177e4 LT |
115 | { |
116 | u32 tmp; | |
117 | int i; | |
118 | ||
b5e89ed5 DA |
119 | tmp = R128_READ(R128_PC_NGUI_CTLSTAT) | R128_PC_FLUSH_ALL; |
120 | R128_WRITE(R128_PC_NGUI_CTLSTAT, tmp); | |
1da177e4 | 121 | |
b5e89ed5 DA |
122 | for (i = 0; i < dev_priv->usec_timeout; i++) { |
123 | if (!(R128_READ(R128_PC_NGUI_CTLSTAT) & R128_PC_BUSY)) { | |
1da177e4 LT |
124 | return 0; |
125 | } | |
b5e89ed5 | 126 | DRM_UDELAY(1); |
1da177e4 LT |
127 | } |
128 | ||
129 | #if R128_FIFO_DEBUG | |
b5e89ed5 | 130 | DRM_ERROR("failed!\n"); |
1da177e4 | 131 | #endif |
20caafa6 | 132 | return -EBUSY; |
1da177e4 LT |
133 | } |
134 | ||
b5e89ed5 | 135 | static int r128_do_wait_for_fifo(drm_r128_private_t * dev_priv, int entries) |
1da177e4 LT |
136 | { |
137 | int i; | |
138 | ||
b5e89ed5 DA |
139 | for (i = 0; i < dev_priv->usec_timeout; i++) { |
140 | int slots = R128_READ(R128_GUI_STAT) & R128_GUI_FIFOCNT_MASK; | |
141 | if (slots >= entries) | |
142 | return 0; | |
143 | DRM_UDELAY(1); | |
1da177e4 LT |
144 | } |
145 | ||
146 | #if R128_FIFO_DEBUG | |
b5e89ed5 | 147 | DRM_ERROR("failed!\n"); |
1da177e4 | 148 | #endif |
20caafa6 | 149 | return -EBUSY; |
1da177e4 LT |
150 | } |
151 | ||
b5e89ed5 | 152 | static int r128_do_wait_for_idle(drm_r128_private_t * dev_priv) |
1da177e4 LT |
153 | { |
154 | int i, ret; | |
155 | ||
b5e89ed5 DA |
156 | ret = r128_do_wait_for_fifo(dev_priv, 64); |
157 | if (ret) | |
158 | return ret; | |
1da177e4 | 159 | |
b5e89ed5 DA |
160 | for (i = 0; i < dev_priv->usec_timeout; i++) { |
161 | if (!(R128_READ(R128_GUI_STAT) & R128_GUI_ACTIVE)) { | |
162 | r128_do_pixcache_flush(dev_priv); | |
1da177e4 LT |
163 | return 0; |
164 | } | |
b5e89ed5 | 165 | DRM_UDELAY(1); |
1da177e4 LT |
166 | } |
167 | ||
168 | #if R128_FIFO_DEBUG | |
b5e89ed5 | 169 | DRM_ERROR("failed!\n"); |
1da177e4 | 170 | #endif |
20caafa6 | 171 | return -EBUSY; |
1da177e4 LT |
172 | } |
173 | ||
1da177e4 LT |
174 | /* ================================================================ |
175 | * CCE control, initialization | |
176 | */ | |
177 | ||
178 | /* Load the microcode for the CCE */ | |
b5e89ed5 | 179 | static void r128_cce_load_microcode(drm_r128_private_t * dev_priv) |
1da177e4 LT |
180 | { |
181 | int i; | |
182 | ||
b5e89ed5 | 183 | DRM_DEBUG("\n"); |
1da177e4 | 184 | |
b5e89ed5 | 185 | r128_do_wait_for_idle(dev_priv); |
1da177e4 | 186 | |
b5e89ed5 DA |
187 | R128_WRITE(R128_PM4_MICROCODE_ADDR, 0); |
188 | for (i = 0; i < 256; i++) { | |
189 | R128_WRITE(R128_PM4_MICROCODE_DATAH, r128_cce_microcode[i * 2]); | |
190 | R128_WRITE(R128_PM4_MICROCODE_DATAL, | |
191 | r128_cce_microcode[i * 2 + 1]); | |
1da177e4 LT |
192 | } |
193 | } | |
194 | ||
195 | /* Flush any pending commands to the CCE. This should only be used just | |
196 | * prior to a wait for idle, as it informs the engine that the command | |
197 | * stream is ending. | |
198 | */ | |
b5e89ed5 | 199 | static void r128_do_cce_flush(drm_r128_private_t * dev_priv) |
1da177e4 LT |
200 | { |
201 | u32 tmp; | |
202 | ||
b5e89ed5 DA |
203 | tmp = R128_READ(R128_PM4_BUFFER_DL_WPTR) | R128_PM4_BUFFER_DL_DONE; |
204 | R128_WRITE(R128_PM4_BUFFER_DL_WPTR, tmp); | |
1da177e4 LT |
205 | } |
206 | ||
207 | /* Wait for the CCE to go idle. | |
208 | */ | |
b5e89ed5 | 209 | int r128_do_cce_idle(drm_r128_private_t * dev_priv) |
1da177e4 LT |
210 | { |
211 | int i; | |
212 | ||
b5e89ed5 DA |
213 | for (i = 0; i < dev_priv->usec_timeout; i++) { |
214 | if (GET_RING_HEAD(dev_priv) == dev_priv->ring.tail) { | |
215 | int pm4stat = R128_READ(R128_PM4_STAT); | |
216 | if (((pm4stat & R128_PM4_FIFOCNT_MASK) >= | |
217 | dev_priv->cce_fifo_size) && | |
218 | !(pm4stat & (R128_PM4_BUSY | | |
219 | R128_PM4_GUI_ACTIVE))) { | |
220 | return r128_do_pixcache_flush(dev_priv); | |
1da177e4 LT |
221 | } |
222 | } | |
b5e89ed5 | 223 | DRM_UDELAY(1); |
1da177e4 LT |
224 | } |
225 | ||
226 | #if R128_FIFO_DEBUG | |
b5e89ed5 DA |
227 | DRM_ERROR("failed!\n"); |
228 | r128_status(dev_priv); | |
1da177e4 | 229 | #endif |
20caafa6 | 230 | return -EBUSY; |
1da177e4 LT |
231 | } |
232 | ||
233 | /* Start the Concurrent Command Engine. | |
234 | */ | |
b5e89ed5 | 235 | static void r128_do_cce_start(drm_r128_private_t * dev_priv) |
1da177e4 | 236 | { |
b5e89ed5 | 237 | r128_do_wait_for_idle(dev_priv); |
1da177e4 | 238 | |
b5e89ed5 DA |
239 | R128_WRITE(R128_PM4_BUFFER_CNTL, |
240 | dev_priv->cce_mode | dev_priv->ring.size_l2qw | |
241 | | R128_PM4_BUFFER_CNTL_NOUPDATE); | |
242 | R128_READ(R128_PM4_BUFFER_ADDR); /* as per the sample code */ | |
243 | R128_WRITE(R128_PM4_MICRO_CNTL, R128_PM4_MICRO_FREERUN); | |
1da177e4 LT |
244 | |
245 | dev_priv->cce_running = 1; | |
246 | } | |
247 | ||
248 | /* Reset the Concurrent Command Engine. This will not flush any pending | |
249 | * commands, so you must wait for the CCE command stream to complete | |
250 | * before calling this routine. | |
251 | */ | |
b5e89ed5 | 252 | static void r128_do_cce_reset(drm_r128_private_t * dev_priv) |
1da177e4 | 253 | { |
b5e89ed5 DA |
254 | R128_WRITE(R128_PM4_BUFFER_DL_WPTR, 0); |
255 | R128_WRITE(R128_PM4_BUFFER_DL_RPTR, 0); | |
1da177e4 LT |
256 | dev_priv->ring.tail = 0; |
257 | } | |
258 | ||
259 | /* Stop the Concurrent Command Engine. This will not flush any pending | |
260 | * commands, so you must flush the command stream and wait for the CCE | |
261 | * to go idle before calling this routine. | |
262 | */ | |
b5e89ed5 | 263 | static void r128_do_cce_stop(drm_r128_private_t * dev_priv) |
1da177e4 | 264 | { |
b5e89ed5 DA |
265 | R128_WRITE(R128_PM4_MICRO_CNTL, 0); |
266 | R128_WRITE(R128_PM4_BUFFER_CNTL, | |
267 | R128_PM4_NONPM4 | R128_PM4_BUFFER_CNTL_NOUPDATE); | |
1da177e4 LT |
268 | |
269 | dev_priv->cce_running = 0; | |
270 | } | |
271 | ||
272 | /* Reset the engine. This will stop the CCE if it is running. | |
273 | */ | |
eddca551 | 274 | static int r128_do_engine_reset(struct drm_device * dev) |
1da177e4 LT |
275 | { |
276 | drm_r128_private_t *dev_priv = dev->dev_private; | |
277 | u32 clock_cntl_index, mclk_cntl, gen_reset_cntl; | |
278 | ||
b5e89ed5 | 279 | r128_do_pixcache_flush(dev_priv); |
1da177e4 | 280 | |
b5e89ed5 DA |
281 | clock_cntl_index = R128_READ(R128_CLOCK_CNTL_INDEX); |
282 | mclk_cntl = R128_READ_PLL(dev, R128_MCLK_CNTL); | |
1da177e4 | 283 | |
b5e89ed5 DA |
284 | R128_WRITE_PLL(R128_MCLK_CNTL, |
285 | mclk_cntl | R128_FORCE_GCP | R128_FORCE_PIPE3D_CP); | |
1da177e4 | 286 | |
b5e89ed5 | 287 | gen_reset_cntl = R128_READ(R128_GEN_RESET_CNTL); |
1da177e4 LT |
288 | |
289 | /* Taken from the sample code - do not change */ | |
b5e89ed5 DA |
290 | R128_WRITE(R128_GEN_RESET_CNTL, gen_reset_cntl | R128_SOFT_RESET_GUI); |
291 | R128_READ(R128_GEN_RESET_CNTL); | |
292 | R128_WRITE(R128_GEN_RESET_CNTL, gen_reset_cntl & ~R128_SOFT_RESET_GUI); | |
293 | R128_READ(R128_GEN_RESET_CNTL); | |
1da177e4 | 294 | |
b5e89ed5 DA |
295 | R128_WRITE_PLL(R128_MCLK_CNTL, mclk_cntl); |
296 | R128_WRITE(R128_CLOCK_CNTL_INDEX, clock_cntl_index); | |
297 | R128_WRITE(R128_GEN_RESET_CNTL, gen_reset_cntl); | |
1da177e4 LT |
298 | |
299 | /* Reset the CCE ring */ | |
b5e89ed5 | 300 | r128_do_cce_reset(dev_priv); |
1da177e4 LT |
301 | |
302 | /* The CCE is no longer running after an engine reset */ | |
303 | dev_priv->cce_running = 0; | |
304 | ||
305 | /* Reset any pending vertex, indirect buffers */ | |
b5e89ed5 | 306 | r128_freelist_reset(dev); |
1da177e4 LT |
307 | |
308 | return 0; | |
309 | } | |
310 | ||
eddca551 | 311 | static void r128_cce_init_ring_buffer(struct drm_device * dev, |
b5e89ed5 | 312 | drm_r128_private_t * dev_priv) |
1da177e4 LT |
313 | { |
314 | u32 ring_start; | |
315 | u32 tmp; | |
316 | ||
b5e89ed5 | 317 | DRM_DEBUG("\n"); |
1da177e4 LT |
318 | |
319 | /* The manual (p. 2) says this address is in "VM space". This | |
320 | * means it's an offset from the start of AGP space. | |
321 | */ | |
322 | #if __OS_HAS_AGP | |
b5e89ed5 | 323 | if (!dev_priv->is_pci) |
1da177e4 LT |
324 | ring_start = dev_priv->cce_ring->offset - dev->agp->base; |
325 | else | |
326 | #endif | |
b5e89ed5 DA |
327 | ring_start = dev_priv->cce_ring->offset - |
328 | (unsigned long)dev->sg->virtual; | |
1da177e4 | 329 | |
b5e89ed5 | 330 | R128_WRITE(R128_PM4_BUFFER_OFFSET, ring_start | R128_AGP_OFFSET); |
1da177e4 | 331 | |
b5e89ed5 DA |
332 | R128_WRITE(R128_PM4_BUFFER_DL_WPTR, 0); |
333 | R128_WRITE(R128_PM4_BUFFER_DL_RPTR, 0); | |
1da177e4 LT |
334 | |
335 | /* Set watermark control */ | |
b5e89ed5 DA |
336 | R128_WRITE(R128_PM4_BUFFER_WM_CNTL, |
337 | ((R128_WATERMARK_L / 4) << R128_WMA_SHIFT) | |
338 | | ((R128_WATERMARK_M / 4) << R128_WMB_SHIFT) | |
339 | | ((R128_WATERMARK_N / 4) << R128_WMC_SHIFT) | |
340 | | ((R128_WATERMARK_K / 64) << R128_WB_WM_SHIFT)); | |
1da177e4 LT |
341 | |
342 | /* Force read. Why? Because it's in the examples... */ | |
b5e89ed5 | 343 | R128_READ(R128_PM4_BUFFER_ADDR); |
1da177e4 LT |
344 | |
345 | /* Turn on bus mastering */ | |
b5e89ed5 DA |
346 | tmp = R128_READ(R128_BUS_CNTL) & ~R128_BUS_MASTER_DIS; |
347 | R128_WRITE(R128_BUS_CNTL, tmp); | |
1da177e4 LT |
348 | } |
349 | ||
eddca551 | 350 | static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init) |
1da177e4 LT |
351 | { |
352 | drm_r128_private_t *dev_priv; | |
353 | ||
b5e89ed5 | 354 | DRM_DEBUG("\n"); |
1da177e4 | 355 | |
b5e89ed5 DA |
356 | dev_priv = drm_alloc(sizeof(drm_r128_private_t), DRM_MEM_DRIVER); |
357 | if (dev_priv == NULL) | |
20caafa6 | 358 | return -ENOMEM; |
1da177e4 | 359 | |
b5e89ed5 | 360 | memset(dev_priv, 0, sizeof(drm_r128_private_t)); |
1da177e4 LT |
361 | |
362 | dev_priv->is_pci = init->is_pci; | |
363 | ||
b5e89ed5 DA |
364 | if (dev_priv->is_pci && !dev->sg) { |
365 | DRM_ERROR("PCI GART memory not allocated!\n"); | |
1da177e4 | 366 | dev->dev_private = (void *)dev_priv; |
b5e89ed5 | 367 | r128_do_cleanup_cce(dev); |
20caafa6 | 368 | return -EINVAL; |
1da177e4 LT |
369 | } |
370 | ||
371 | dev_priv->usec_timeout = init->usec_timeout; | |
b5e89ed5 DA |
372 | if (dev_priv->usec_timeout < 1 || |
373 | dev_priv->usec_timeout > R128_MAX_USEC_TIMEOUT) { | |
374 | DRM_DEBUG("TIMEOUT problem!\n"); | |
1da177e4 | 375 | dev->dev_private = (void *)dev_priv; |
b5e89ed5 | 376 | r128_do_cleanup_cce(dev); |
20caafa6 | 377 | return -EINVAL; |
1da177e4 LT |
378 | } |
379 | ||
380 | dev_priv->cce_mode = init->cce_mode; | |
381 | ||
382 | /* GH: Simple idle check. | |
383 | */ | |
b5e89ed5 | 384 | atomic_set(&dev_priv->idle_count, 0); |
1da177e4 LT |
385 | |
386 | /* We don't support anything other than bus-mastering ring mode, | |
387 | * but the ring can be in either AGP or PCI space for the ring | |
388 | * read pointer. | |
389 | */ | |
b5e89ed5 DA |
390 | if ((init->cce_mode != R128_PM4_192BM) && |
391 | (init->cce_mode != R128_PM4_128BM_64INDBM) && | |
392 | (init->cce_mode != R128_PM4_64BM_128INDBM) && | |
393 | (init->cce_mode != R128_PM4_64BM_64VCBM_64INDBM)) { | |
394 | DRM_DEBUG("Bad cce_mode!\n"); | |
1da177e4 | 395 | dev->dev_private = (void *)dev_priv; |
b5e89ed5 | 396 | r128_do_cleanup_cce(dev); |
20caafa6 | 397 | return -EINVAL; |
1da177e4 LT |
398 | } |
399 | ||
b5e89ed5 | 400 | switch (init->cce_mode) { |
1da177e4 LT |
401 | case R128_PM4_NONPM4: |
402 | dev_priv->cce_fifo_size = 0; | |
403 | break; | |
404 | case R128_PM4_192PIO: | |
405 | case R128_PM4_192BM: | |
406 | dev_priv->cce_fifo_size = 192; | |
407 | break; | |
408 | case R128_PM4_128PIO_64INDBM: | |
409 | case R128_PM4_128BM_64INDBM: | |
410 | dev_priv->cce_fifo_size = 128; | |
411 | break; | |
412 | case R128_PM4_64PIO_128INDBM: | |
413 | case R128_PM4_64BM_128INDBM: | |
414 | case R128_PM4_64PIO_64VCBM_64INDBM: | |
415 | case R128_PM4_64BM_64VCBM_64INDBM: | |
416 | case R128_PM4_64PIO_64VCPIO_64INDPIO: | |
417 | dev_priv->cce_fifo_size = 64; | |
418 | break; | |
419 | } | |
420 | ||
b5e89ed5 | 421 | switch (init->fb_bpp) { |
1da177e4 LT |
422 | case 16: |
423 | dev_priv->color_fmt = R128_DATATYPE_RGB565; | |
424 | break; | |
425 | case 32: | |
426 | default: | |
427 | dev_priv->color_fmt = R128_DATATYPE_ARGB8888; | |
428 | break; | |
429 | } | |
b5e89ed5 DA |
430 | dev_priv->front_offset = init->front_offset; |
431 | dev_priv->front_pitch = init->front_pitch; | |
432 | dev_priv->back_offset = init->back_offset; | |
433 | dev_priv->back_pitch = init->back_pitch; | |
1da177e4 | 434 | |
b5e89ed5 | 435 | switch (init->depth_bpp) { |
1da177e4 LT |
436 | case 16: |
437 | dev_priv->depth_fmt = R128_DATATYPE_RGB565; | |
438 | break; | |
439 | case 24: | |
440 | case 32: | |
441 | default: | |
442 | dev_priv->depth_fmt = R128_DATATYPE_ARGB8888; | |
443 | break; | |
444 | } | |
b5e89ed5 DA |
445 | dev_priv->depth_offset = init->depth_offset; |
446 | dev_priv->depth_pitch = init->depth_pitch; | |
447 | dev_priv->span_offset = init->span_offset; | |
1da177e4 | 448 | |
b5e89ed5 | 449 | dev_priv->front_pitch_offset_c = (((dev_priv->front_pitch / 8) << 21) | |
1da177e4 | 450 | (dev_priv->front_offset >> 5)); |
b5e89ed5 | 451 | dev_priv->back_pitch_offset_c = (((dev_priv->back_pitch / 8) << 21) | |
1da177e4 | 452 | (dev_priv->back_offset >> 5)); |
b5e89ed5 | 453 | dev_priv->depth_pitch_offset_c = (((dev_priv->depth_pitch / 8) << 21) | |
1da177e4 LT |
454 | (dev_priv->depth_offset >> 5) | |
455 | R128_DST_TILE); | |
b5e89ed5 | 456 | dev_priv->span_pitch_offset_c = (((dev_priv->depth_pitch / 8) << 21) | |
1da177e4 LT |
457 | (dev_priv->span_offset >> 5)); |
458 | ||
da509d7a | 459 | dev_priv->sarea = drm_getsarea(dev); |
b5e89ed5 | 460 | if (!dev_priv->sarea) { |
1da177e4 LT |
461 | DRM_ERROR("could not find sarea!\n"); |
462 | dev->dev_private = (void *)dev_priv; | |
b5e89ed5 | 463 | r128_do_cleanup_cce(dev); |
20caafa6 | 464 | return -EINVAL; |
1da177e4 LT |
465 | } |
466 | ||
467 | dev_priv->mmio = drm_core_findmap(dev, init->mmio_offset); | |
b5e89ed5 | 468 | if (!dev_priv->mmio) { |
1da177e4 LT |
469 | DRM_ERROR("could not find mmio region!\n"); |
470 | dev->dev_private = (void *)dev_priv; | |
b5e89ed5 | 471 | r128_do_cleanup_cce(dev); |
20caafa6 | 472 | return -EINVAL; |
1da177e4 LT |
473 | } |
474 | dev_priv->cce_ring = drm_core_findmap(dev, init->ring_offset); | |
b5e89ed5 | 475 | if (!dev_priv->cce_ring) { |
1da177e4 LT |
476 | DRM_ERROR("could not find cce ring region!\n"); |
477 | dev->dev_private = (void *)dev_priv; | |
b5e89ed5 | 478 | r128_do_cleanup_cce(dev); |
20caafa6 | 479 | return -EINVAL; |
1da177e4 LT |
480 | } |
481 | dev_priv->ring_rptr = drm_core_findmap(dev, init->ring_rptr_offset); | |
b5e89ed5 | 482 | if (!dev_priv->ring_rptr) { |
1da177e4 LT |
483 | DRM_ERROR("could not find ring read pointer!\n"); |
484 | dev->dev_private = (void *)dev_priv; | |
b5e89ed5 | 485 | r128_do_cleanup_cce(dev); |
20caafa6 | 486 | return -EINVAL; |
1da177e4 | 487 | } |
d1f2b55a | 488 | dev->agp_buffer_token = init->buffers_offset; |
1da177e4 | 489 | dev->agp_buffer_map = drm_core_findmap(dev, init->buffers_offset); |
b5e89ed5 | 490 | if (!dev->agp_buffer_map) { |
1da177e4 LT |
491 | DRM_ERROR("could not find dma buffer region!\n"); |
492 | dev->dev_private = (void *)dev_priv; | |
b5e89ed5 | 493 | r128_do_cleanup_cce(dev); |
20caafa6 | 494 | return -EINVAL; |
1da177e4 LT |
495 | } |
496 | ||
b5e89ed5 DA |
497 | if (!dev_priv->is_pci) { |
498 | dev_priv->agp_textures = | |
499 | drm_core_findmap(dev, init->agp_textures_offset); | |
500 | if (!dev_priv->agp_textures) { | |
1da177e4 LT |
501 | DRM_ERROR("could not find agp texture region!\n"); |
502 | dev->dev_private = (void *)dev_priv; | |
b5e89ed5 | 503 | r128_do_cleanup_cce(dev); |
20caafa6 | 504 | return -EINVAL; |
1da177e4 LT |
505 | } |
506 | } | |
507 | ||
508 | dev_priv->sarea_priv = | |
b5e89ed5 DA |
509 | (drm_r128_sarea_t *) ((u8 *) dev_priv->sarea->handle + |
510 | init->sarea_priv_offset); | |
1da177e4 LT |
511 | |
512 | #if __OS_HAS_AGP | |
b5e89ed5 DA |
513 | if (!dev_priv->is_pci) { |
514 | drm_core_ioremap(dev_priv->cce_ring, dev); | |
515 | drm_core_ioremap(dev_priv->ring_rptr, dev); | |
516 | drm_core_ioremap(dev->agp_buffer_map, dev); | |
517 | if (!dev_priv->cce_ring->handle || | |
518 | !dev_priv->ring_rptr->handle || | |
519 | !dev->agp_buffer_map->handle) { | |
1da177e4 LT |
520 | DRM_ERROR("Could not ioremap agp regions!\n"); |
521 | dev->dev_private = (void *)dev_priv; | |
b5e89ed5 | 522 | r128_do_cleanup_cce(dev); |
20caafa6 | 523 | return -ENOMEM; |
1da177e4 LT |
524 | } |
525 | } else | |
526 | #endif | |
527 | { | |
41c2e75e BH |
528 | dev_priv->cce_ring->handle = |
529 | (void *)(unsigned long)dev_priv->cce_ring->offset; | |
1da177e4 | 530 | dev_priv->ring_rptr->handle = |
41c2e75e | 531 | (void *)(unsigned long)dev_priv->ring_rptr->offset; |
b5e89ed5 | 532 | dev->agp_buffer_map->handle = |
41c2e75e | 533 | (void *)(unsigned long)dev->agp_buffer_map->offset; |
1da177e4 LT |
534 | } |
535 | ||
536 | #if __OS_HAS_AGP | |
b5e89ed5 | 537 | if (!dev_priv->is_pci) |
1da177e4 LT |
538 | dev_priv->cce_buffers_offset = dev->agp->base; |
539 | else | |
540 | #endif | |
d1f2b55a | 541 | dev_priv->cce_buffers_offset = (unsigned long)dev->sg->virtual; |
1da177e4 | 542 | |
b5e89ed5 DA |
543 | dev_priv->ring.start = (u32 *) dev_priv->cce_ring->handle; |
544 | dev_priv->ring.end = ((u32 *) dev_priv->cce_ring->handle | |
1da177e4 LT |
545 | + init->ring_size / sizeof(u32)); |
546 | dev_priv->ring.size = init->ring_size; | |
b5e89ed5 | 547 | dev_priv->ring.size_l2qw = drm_order(init->ring_size / 8); |
1da177e4 | 548 | |
b5e89ed5 | 549 | dev_priv->ring.tail_mask = (dev_priv->ring.size / sizeof(u32)) - 1; |
1da177e4 LT |
550 | |
551 | dev_priv->ring.high_mark = 128; | |
552 | ||
553 | dev_priv->sarea_priv->last_frame = 0; | |
b5e89ed5 | 554 | R128_WRITE(R128_LAST_FRAME_REG, dev_priv->sarea_priv->last_frame); |
1da177e4 LT |
555 | |
556 | dev_priv->sarea_priv->last_dispatch = 0; | |
b5e89ed5 | 557 | R128_WRITE(R128_LAST_DISPATCH_REG, dev_priv->sarea_priv->last_dispatch); |
1da177e4 LT |
558 | |
559 | #if __OS_HAS_AGP | |
b5e89ed5 | 560 | if (dev_priv->is_pci) { |
1da177e4 | 561 | #endif |
b05c2385 | 562 | dev_priv->gart_info.table_mask = DMA_BIT_MASK(32); |
ea98a92f | 563 | dev_priv->gart_info.gart_table_location = DRM_ATI_GART_MAIN; |
f2b04cd2 | 564 | dev_priv->gart_info.table_size = R128_PCIGART_TABLE_SIZE; |
f26c473c DA |
565 | dev_priv->gart_info.addr = NULL; |
566 | dev_priv->gart_info.bus_addr = 0; | |
f2b04cd2 | 567 | dev_priv->gart_info.gart_reg_if = DRM_ATI_GART_PCI; |
ea98a92f | 568 | if (!drm_ati_pcigart_init(dev, &dev_priv->gart_info)) { |
b5e89ed5 | 569 | DRM_ERROR("failed to init PCI GART!\n"); |
1da177e4 | 570 | dev->dev_private = (void *)dev_priv; |
b5e89ed5 | 571 | r128_do_cleanup_cce(dev); |
20caafa6 | 572 | return -ENOMEM; |
1da177e4 | 573 | } |
ea98a92f | 574 | R128_WRITE(R128_PCI_GART_PAGE, dev_priv->gart_info.bus_addr); |
1da177e4 LT |
575 | #if __OS_HAS_AGP |
576 | } | |
577 | #endif | |
578 | ||
b5e89ed5 DA |
579 | r128_cce_init_ring_buffer(dev, dev_priv); |
580 | r128_cce_load_microcode(dev_priv); | |
1da177e4 LT |
581 | |
582 | dev->dev_private = (void *)dev_priv; | |
583 | ||
b5e89ed5 | 584 | r128_do_engine_reset(dev); |
1da177e4 LT |
585 | |
586 | return 0; | |
587 | } | |
588 | ||
eddca551 | 589 | int r128_do_cleanup_cce(struct drm_device * dev) |
1da177e4 LT |
590 | { |
591 | ||
592 | /* Make sure interrupts are disabled here because the uninstall ioctl | |
593 | * may not have been called from userspace and after dev_private | |
594 | * is freed, it's too late. | |
595 | */ | |
b5e89ed5 DA |
596 | if (dev->irq_enabled) |
597 | drm_irq_uninstall(dev); | |
1da177e4 | 598 | |
b5e89ed5 | 599 | if (dev->dev_private) { |
1da177e4 LT |
600 | drm_r128_private_t *dev_priv = dev->dev_private; |
601 | ||
602 | #if __OS_HAS_AGP | |
b5e89ed5 DA |
603 | if (!dev_priv->is_pci) { |
604 | if (dev_priv->cce_ring != NULL) | |
605 | drm_core_ioremapfree(dev_priv->cce_ring, dev); | |
606 | if (dev_priv->ring_rptr != NULL) | |
607 | drm_core_ioremapfree(dev_priv->ring_rptr, dev); | |
f26c473c | 608 | if (dev->agp_buffer_map != NULL) { |
b5e89ed5 | 609 | drm_core_ioremapfree(dev->agp_buffer_map, dev); |
f26c473c DA |
610 | dev->agp_buffer_map = NULL; |
611 | } | |
1da177e4 LT |
612 | } else |
613 | #endif | |
614 | { | |
b5e89ed5 DA |
615 | if (dev_priv->gart_info.bus_addr) |
616 | if (!drm_ati_pcigart_cleanup(dev, | |
f26c473c | 617 | &dev_priv->gart_info)) |
b5e89ed5 DA |
618 | DRM_ERROR |
619 | ("failed to cleanup PCI GART!\n"); | |
1da177e4 LT |
620 | } |
621 | ||
b5e89ed5 DA |
622 | drm_free(dev->dev_private, sizeof(drm_r128_private_t), |
623 | DRM_MEM_DRIVER); | |
1da177e4 LT |
624 | dev->dev_private = NULL; |
625 | } | |
626 | ||
627 | return 0; | |
628 | } | |
629 | ||
c153f45f | 630 | int r128_cce_init(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 631 | { |
c153f45f | 632 | drm_r128_init_t *init = data; |
1da177e4 | 633 | |
b5e89ed5 | 634 | DRM_DEBUG("\n"); |
1da177e4 | 635 | |
6c340eac | 636 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
1da177e4 | 637 | |
c153f45f | 638 | switch (init->func) { |
1da177e4 | 639 | case R128_INIT_CCE: |
c153f45f | 640 | return r128_do_init_cce(dev, init); |
1da177e4 | 641 | case R128_CLEANUP_CCE: |
b5e89ed5 | 642 | return r128_do_cleanup_cce(dev); |
1da177e4 LT |
643 | } |
644 | ||
20caafa6 | 645 | return -EINVAL; |
1da177e4 LT |
646 | } |
647 | ||
c153f45f | 648 | int r128_cce_start(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 649 | { |
1da177e4 | 650 | drm_r128_private_t *dev_priv = dev->dev_private; |
b5e89ed5 | 651 | DRM_DEBUG("\n"); |
1da177e4 | 652 | |
6c340eac | 653 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
1da177e4 | 654 | |
b5e89ed5 | 655 | if (dev_priv->cce_running || dev_priv->cce_mode == R128_PM4_NONPM4) { |
3e684eae | 656 | DRM_DEBUG("while CCE running\n"); |
1da177e4 LT |
657 | return 0; |
658 | } | |
659 | ||
b5e89ed5 | 660 | r128_do_cce_start(dev_priv); |
1da177e4 LT |
661 | |
662 | return 0; | |
663 | } | |
664 | ||
665 | /* Stop the CCE. The engine must have been idled before calling this | |
666 | * routine. | |
667 | */ | |
c153f45f | 668 | int r128_cce_stop(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 669 | { |
1da177e4 | 670 | drm_r128_private_t *dev_priv = dev->dev_private; |
c153f45f | 671 | drm_r128_cce_stop_t *stop = data; |
1da177e4 | 672 | int ret; |
b5e89ed5 | 673 | DRM_DEBUG("\n"); |
1da177e4 | 674 | |
6c340eac | 675 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
1da177e4 | 676 | |
1da177e4 LT |
677 | /* Flush any pending CCE commands. This ensures any outstanding |
678 | * commands are exectuted by the engine before we turn it off. | |
679 | */ | |
c153f45f | 680 | if (stop->flush) { |
b5e89ed5 | 681 | r128_do_cce_flush(dev_priv); |
1da177e4 LT |
682 | } |
683 | ||
684 | /* If we fail to make the engine go idle, we return an error | |
685 | * code so that the DRM ioctl wrapper can try again. | |
686 | */ | |
c153f45f | 687 | if (stop->idle) { |
b5e89ed5 DA |
688 | ret = r128_do_cce_idle(dev_priv); |
689 | if (ret) | |
690 | return ret; | |
1da177e4 LT |
691 | } |
692 | ||
693 | /* Finally, we can turn off the CCE. If the engine isn't idle, | |
694 | * we will get some dropped triangles as they won't be fully | |
695 | * rendered before the CCE is shut down. | |
696 | */ | |
b5e89ed5 | 697 | r128_do_cce_stop(dev_priv); |
1da177e4 LT |
698 | |
699 | /* Reset the engine */ | |
b5e89ed5 | 700 | r128_do_engine_reset(dev); |
1da177e4 LT |
701 | |
702 | return 0; | |
703 | } | |
704 | ||
705 | /* Just reset the CCE ring. Called as part of an X Server engine reset. | |
706 | */ | |
c153f45f | 707 | int r128_cce_reset(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 708 | { |
1da177e4 | 709 | drm_r128_private_t *dev_priv = dev->dev_private; |
b5e89ed5 | 710 | DRM_DEBUG("\n"); |
1da177e4 | 711 | |
6c340eac | 712 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
1da177e4 | 713 | |
b5e89ed5 | 714 | if (!dev_priv) { |
3e684eae | 715 | DRM_DEBUG("called before init done\n"); |
20caafa6 | 716 | return -EINVAL; |
1da177e4 LT |
717 | } |
718 | ||
b5e89ed5 | 719 | r128_do_cce_reset(dev_priv); |
1da177e4 LT |
720 | |
721 | /* The CCE is no longer running after an engine reset */ | |
722 | dev_priv->cce_running = 0; | |
723 | ||
724 | return 0; | |
725 | } | |
726 | ||
c153f45f | 727 | int r128_cce_idle(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 728 | { |
1da177e4 | 729 | drm_r128_private_t *dev_priv = dev->dev_private; |
b5e89ed5 | 730 | DRM_DEBUG("\n"); |
1da177e4 | 731 | |
6c340eac | 732 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
1da177e4 | 733 | |
b5e89ed5 DA |
734 | if (dev_priv->cce_running) { |
735 | r128_do_cce_flush(dev_priv); | |
1da177e4 LT |
736 | } |
737 | ||
b5e89ed5 | 738 | return r128_do_cce_idle(dev_priv); |
1da177e4 LT |
739 | } |
740 | ||
c153f45f | 741 | int r128_engine_reset(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 742 | { |
b5e89ed5 | 743 | DRM_DEBUG("\n"); |
1da177e4 | 744 | |
6c340eac | 745 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
1da177e4 | 746 | |
b5e89ed5 | 747 | return r128_do_engine_reset(dev); |
1da177e4 LT |
748 | } |
749 | ||
c153f45f | 750 | int r128_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 751 | { |
20caafa6 | 752 | return -EINVAL; |
1da177e4 LT |
753 | } |
754 | ||
1da177e4 LT |
755 | /* ================================================================ |
756 | * Freelist management | |
757 | */ | |
758 | #define R128_BUFFER_USED 0xffffffff | |
759 | #define R128_BUFFER_FREE 0 | |
760 | ||
761 | #if 0 | |
eddca551 | 762 | static int r128_freelist_init(struct drm_device * dev) |
1da177e4 | 763 | { |
cdd55a29 | 764 | struct drm_device_dma *dma = dev->dma; |
1da177e4 | 765 | drm_r128_private_t *dev_priv = dev->dev_private; |
056219e2 | 766 | struct drm_buf *buf; |
1da177e4 LT |
767 | drm_r128_buf_priv_t *buf_priv; |
768 | drm_r128_freelist_t *entry; | |
769 | int i; | |
770 | ||
b5e89ed5 DA |
771 | dev_priv->head = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER); |
772 | if (dev_priv->head == NULL) | |
20caafa6 | 773 | return -ENOMEM; |
1da177e4 | 774 | |
b5e89ed5 | 775 | memset(dev_priv->head, 0, sizeof(drm_r128_freelist_t)); |
1da177e4 LT |
776 | dev_priv->head->age = R128_BUFFER_USED; |
777 | ||
b5e89ed5 | 778 | for (i = 0; i < dma->buf_count; i++) { |
1da177e4 LT |
779 | buf = dma->buflist[i]; |
780 | buf_priv = buf->dev_private; | |
781 | ||
b5e89ed5 DA |
782 | entry = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER); |
783 | if (!entry) | |
20caafa6 | 784 | return -ENOMEM; |
1da177e4 LT |
785 | |
786 | entry->age = R128_BUFFER_FREE; | |
787 | entry->buf = buf; | |
788 | entry->prev = dev_priv->head; | |
789 | entry->next = dev_priv->head->next; | |
b5e89ed5 | 790 | if (!entry->next) |
1da177e4 LT |
791 | dev_priv->tail = entry; |
792 | ||
793 | buf_priv->discard = 0; | |
794 | buf_priv->dispatched = 0; | |
795 | buf_priv->list_entry = entry; | |
796 | ||
797 | dev_priv->head->next = entry; | |
798 | ||
b5e89ed5 | 799 | if (dev_priv->head->next) |
1da177e4 LT |
800 | dev_priv->head->next->prev = entry; |
801 | } | |
802 | ||
803 | return 0; | |
804 | ||
805 | } | |
806 | #endif | |
807 | ||
056219e2 | 808 | static struct drm_buf *r128_freelist_get(struct drm_device * dev) |
1da177e4 | 809 | { |
cdd55a29 | 810 | struct drm_device_dma *dma = dev->dma; |
1da177e4 LT |
811 | drm_r128_private_t *dev_priv = dev->dev_private; |
812 | drm_r128_buf_priv_t *buf_priv; | |
056219e2 | 813 | struct drm_buf *buf; |
1da177e4 LT |
814 | int i, t; |
815 | ||
816 | /* FIXME: Optimize -- use freelist code */ | |
817 | ||
b5e89ed5 | 818 | for (i = 0; i < dma->buf_count; i++) { |
1da177e4 LT |
819 | buf = dma->buflist[i]; |
820 | buf_priv = buf->dev_private; | |
8da56309 | 821 | if (!buf->file_priv) |
1da177e4 LT |
822 | return buf; |
823 | } | |
824 | ||
b5e89ed5 DA |
825 | for (t = 0; t < dev_priv->usec_timeout; t++) { |
826 | u32 done_age = R128_READ(R128_LAST_DISPATCH_REG); | |
1da177e4 | 827 | |
b5e89ed5 | 828 | for (i = 0; i < dma->buf_count; i++) { |
1da177e4 LT |
829 | buf = dma->buflist[i]; |
830 | buf_priv = buf->dev_private; | |
b5e89ed5 | 831 | if (buf->pending && buf_priv->age <= done_age) { |
1da177e4 LT |
832 | /* The buffer has been processed, so it |
833 | * can now be used. | |
834 | */ | |
835 | buf->pending = 0; | |
836 | return buf; | |
837 | } | |
838 | } | |
b5e89ed5 | 839 | DRM_UDELAY(1); |
1da177e4 LT |
840 | } |
841 | ||
b5e89ed5 | 842 | DRM_DEBUG("returning NULL!\n"); |
1da177e4 LT |
843 | return NULL; |
844 | } | |
845 | ||
eddca551 | 846 | void r128_freelist_reset(struct drm_device * dev) |
1da177e4 | 847 | { |
cdd55a29 | 848 | struct drm_device_dma *dma = dev->dma; |
1da177e4 LT |
849 | int i; |
850 | ||
b5e89ed5 | 851 | for (i = 0; i < dma->buf_count; i++) { |
056219e2 | 852 | struct drm_buf *buf = dma->buflist[i]; |
1da177e4 LT |
853 | drm_r128_buf_priv_t *buf_priv = buf->dev_private; |
854 | buf_priv->age = 0; | |
855 | } | |
856 | } | |
857 | ||
1da177e4 LT |
858 | /* ================================================================ |
859 | * CCE command submission | |
860 | */ | |
861 | ||
b5e89ed5 | 862 | int r128_wait_ring(drm_r128_private_t * dev_priv, int n) |
1da177e4 LT |
863 | { |
864 | drm_r128_ring_buffer_t *ring = &dev_priv->ring; | |
865 | int i; | |
866 | ||
b5e89ed5 DA |
867 | for (i = 0; i < dev_priv->usec_timeout; i++) { |
868 | r128_update_ring_snapshot(dev_priv); | |
869 | if (ring->space >= n) | |
1da177e4 | 870 | return 0; |
b5e89ed5 | 871 | DRM_UDELAY(1); |
1da177e4 LT |
872 | } |
873 | ||
874 | /* FIXME: This is being ignored... */ | |
b5e89ed5 | 875 | DRM_ERROR("failed!\n"); |
20caafa6 | 876 | return -EBUSY; |
1da177e4 LT |
877 | } |
878 | ||
6c340eac EA |
879 | static int r128_cce_get_buffers(struct drm_device * dev, |
880 | struct drm_file *file_priv, | |
881 | struct drm_dma * d) | |
1da177e4 LT |
882 | { |
883 | int i; | |
056219e2 | 884 | struct drm_buf *buf; |
1da177e4 | 885 | |
b5e89ed5 DA |
886 | for (i = d->granted_count; i < d->request_count; i++) { |
887 | buf = r128_freelist_get(dev); | |
888 | if (!buf) | |
20caafa6 | 889 | return -EAGAIN; |
1da177e4 | 890 | |
6c340eac | 891 | buf->file_priv = file_priv; |
1da177e4 | 892 | |
b5e89ed5 DA |
893 | if (DRM_COPY_TO_USER(&d->request_indices[i], &buf->idx, |
894 | sizeof(buf->idx))) | |
20caafa6 | 895 | return -EFAULT; |
b5e89ed5 DA |
896 | if (DRM_COPY_TO_USER(&d->request_sizes[i], &buf->total, |
897 | sizeof(buf->total))) | |
20caafa6 | 898 | return -EFAULT; |
1da177e4 LT |
899 | |
900 | d->granted_count++; | |
901 | } | |
902 | return 0; | |
903 | } | |
904 | ||
c153f45f | 905 | int r128_cce_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv) |
1da177e4 | 906 | { |
cdd55a29 | 907 | struct drm_device_dma *dma = dev->dma; |
1da177e4 | 908 | int ret = 0; |
c153f45f | 909 | struct drm_dma *d = data; |
1da177e4 | 910 | |
6c340eac | 911 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
1da177e4 | 912 | |
1da177e4 LT |
913 | /* Please don't send us buffers. |
914 | */ | |
c153f45f | 915 | if (d->send_count != 0) { |
b5e89ed5 | 916 | DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n", |
c153f45f | 917 | DRM_CURRENTPID, d->send_count); |
20caafa6 | 918 | return -EINVAL; |
1da177e4 LT |
919 | } |
920 | ||
921 | /* We'll send you buffers. | |
922 | */ | |
c153f45f | 923 | if (d->request_count < 0 || d->request_count > dma->buf_count) { |
b5e89ed5 | 924 | DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n", |
c153f45f | 925 | DRM_CURRENTPID, d->request_count, dma->buf_count); |
20caafa6 | 926 | return -EINVAL; |
1da177e4 LT |
927 | } |
928 | ||
c153f45f | 929 | d->granted_count = 0; |
1da177e4 | 930 | |
c153f45f EA |
931 | if (d->request_count) { |
932 | ret = r128_cce_get_buffers(dev, file_priv, d); | |
1da177e4 LT |
933 | } |
934 | ||
1da177e4 LT |
935 | return ret; |
936 | } |