2 * Copyright © 2008 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
24 * Eric Anholt <eric@anholt.net>
33 /** @file i915_gem_tiling.c
35 * Support for managing tiling state of buffer objects.
37 * The idea behind tiling is to increase cache hit rates by rearranging
38 * pixel data so that a group of pixel accesses are in the same cacheline.
39 * Performance improvement from doing this on the back/depth buffer are on
42 * Intel architectures make this somewhat more complicated, though, by
43 * adjustments made to addressing of data when the memory is in interleaved
44 * mode (matched pairs of DIMMS) to improve memory bandwidth.
45 * For interleaved memory, the CPU sends every sequential 64 bytes
46 * to an alternate memory channel so it can get the bandwidth from both.
48 * The GPU also rearranges its accesses for increased bandwidth to interleaved
49 * memory, and it matches what the CPU does for non-tiled. However, when tiled
50 * it does it a little differently, since one walks addresses not just in the
51 * X direction but also Y. So, along with alternating channels when bit
52 * 6 of the address flips, it also alternates when other bits flip -- Bits 9
53 * (every 512 bytes, an X tile scanline) and 10 (every two X tile scanlines)
54 * are common to both the 915 and 965-class hardware.
56 * The CPU also sometimes XORs in higher bits as well, to improve
57 * bandwidth doing strided access like we do so frequently in graphics. This
58 * is called "Channel XOR Randomization" in the MCH documentation. The result
59 * is that the CPU is XORing in either bit 11 or bit 17 to bit 6 of its address
62 * All of this bit 6 XORing has an effect on our memory management,
63 * as we need to make sure that the 3d driver can correctly address object
66 * If we don't have interleaved memory, all tiling is safe and no swizzling is
69 * When bit 17 is XORed in, we simply refuse to tile at all. Bit
70 * 17 is not just a page offset, so as we page an objet out and back in,
71 * individual pages in it will have different bit 17 addresses, resulting in
72 * each 64 bytes being swapped with its neighbor!
74 * Otherwise, if interleaved, we have to tell the 3d driver what the address
75 * swizzling it needs to do is, since it's writing with the CPU to the pages
76 * (bit 6 and potentially bit 11 XORed in), and the GPU is reading from the
77 * pages (bit 6, 9, and 10 XORed in), resulting in a cumulative bit swizzling
78 * required by the CPU of XORing in bit 6, 9, 10, and potentially 11, in order
79 * to match what the GPU expects.
83 * Detects bit 6 swizzling of address lookup between IGD access and CPU
84 * access through main memory.
87 i915_gem_detect_bit_6_swizzle(struct drm_device *dev)
89 drm_i915_private_t *dev_priv = dev->dev_private;
90 struct pci_dev *bridge;
91 uint32_t swizzle_x = I915_BIT_6_SWIZZLE_UNKNOWN;
92 uint32_t swizzle_y = I915_BIT_6_SWIZZLE_UNKNOWN;
97 bridge = pci_get_bus_and_slot(0, PCI_DEVFN(0, 0));
99 DRM_ERROR("Couldn't get bridge device\n");
103 ret = pci_enable_device(bridge);
105 DRM_ERROR("pci_enable_device failed: %d\n", ret);
110 mchbar_offset = 0x48;
112 mchbar_offset = 0x44;
114 /* Use resource 2 for our BAR that's stashed in a nonstandard location,
115 * since the bridge would only ever use standard BARs 0-1 (though it
118 ret = pci_read_base(bridge, mchbar_offset, &bridge->resource[2]);
120 DRM_ERROR("pci_read_base failed: %d\n", ret);
124 mchbar = ioremap(pci_resource_start(bridge, 2),
125 pci_resource_len(bridge, 2));
126 if (mchbar == NULL) {
127 DRM_ERROR("Couldn't map MCHBAR to determine tile swizzling\n");
131 if (IS_I965G(dev) && !IS_I965GM(dev)) {
134 /* On the 965, channel interleave appears to be determined by
135 * the flex bit. If flex is set, then the ranks (sides of a
136 * DIMM) of memory will be "stacked" (physical addresses walk
137 * through one rank then move on to the next, flipping channels
138 * or not depending on rank configuration). The GPU in this
139 * case does exactly the same addressing as the CPU.
141 * Unlike the 945, channel randomization based does not
142 * appear to be available.
144 * XXX: While the G965 doesn't appear to do any interleaving
145 * when the DIMMs are not exactly matched, the G4x chipsets
146 * might be for "L-shaped" configurations, and will need to be
149 * L-shaped configuration:
153 * |DIMM2| <-- non-interleaved
157 * |DIMM0| |DIMM1| <-- interleaved area
160 chdecmisc = readb(mchbar + CHDECMISC);
162 if (chdecmisc == 0xff) {
163 DRM_ERROR("Couldn't read from MCHBAR. "
164 "Disabling tiling.\n");
165 } else if (chdecmisc & CHDECMISC_FLEXMEMORY) {
166 swizzle_x = I915_BIT_6_SWIZZLE_NONE;
167 swizzle_y = I915_BIT_6_SWIZZLE_NONE;
169 swizzle_x = I915_BIT_6_SWIZZLE_9_10;
170 swizzle_y = I915_BIT_6_SWIZZLE_9;
172 } else if (IS_I9XX(dev)) {
175 /* On 915-945 and GM965, channel interleave by the CPU is
176 * determined by DCC. The CPU will alternate based on bit 6
177 * in interleaved mode, and the GPU will then also alternate
178 * on bit 6, 9, and 10 for X, but the CPU may also optionally
179 * alternate based on bit 17 (XOR not disabled and XOR
182 dcc = readl(mchbar + DCC);
183 switch (dcc & DCC_ADDRESSING_MODE_MASK) {
184 case DCC_ADDRESSING_MODE_SINGLE_CHANNEL:
185 case DCC_ADDRESSING_MODE_DUAL_CHANNEL_ASYMMETRIC:
186 swizzle_x = I915_BIT_6_SWIZZLE_NONE;
187 swizzle_y = I915_BIT_6_SWIZZLE_NONE;
189 case DCC_ADDRESSING_MODE_DUAL_CHANNEL_INTERLEAVED:
190 if (IS_I915G(dev) || IS_I915GM(dev) ||
191 dcc & DCC_CHANNEL_XOR_DISABLE) {
192 swizzle_x = I915_BIT_6_SWIZZLE_9_10;
193 swizzle_y = I915_BIT_6_SWIZZLE_9;
194 } else if (IS_I965GM(dev)) {
195 /* GM965 only does bit 11-based channel
198 swizzle_x = I915_BIT_6_SWIZZLE_9_10_11;
199 swizzle_y = I915_BIT_6_SWIZZLE_9_11;
201 /* Bit 17 or perhaps other swizzling */
202 swizzle_x = I915_BIT_6_SWIZZLE_UNKNOWN;
203 swizzle_y = I915_BIT_6_SWIZZLE_UNKNOWN;
207 if (dcc == 0xffffffff) {
208 DRM_ERROR("Couldn't read from MCHBAR. "
209 "Disabling tiling.\n");
210 swizzle_x = I915_BIT_6_SWIZZLE_UNKNOWN;
211 swizzle_y = I915_BIT_6_SWIZZLE_UNKNOWN;
214 /* As far as we know, the 865 doesn't have these bit 6
217 swizzle_x = I915_BIT_6_SWIZZLE_NONE;
218 swizzle_y = I915_BIT_6_SWIZZLE_NONE;
223 dev_priv->mm.bit_6_swizzle_x = swizzle_x;
224 dev_priv->mm.bit_6_swizzle_y = swizzle_y;
228 * Sets the tiling mode of an object, returning the required swizzling of
229 * bit 6 of addresses in the object.
232 i915_gem_set_tiling(struct drm_device *dev, void *data,
233 struct drm_file *file_priv)
235 struct drm_i915_gem_set_tiling *args = data;
236 drm_i915_private_t *dev_priv = dev->dev_private;
237 struct drm_gem_object *obj;
238 struct drm_i915_gem_object *obj_priv;
240 obj = drm_gem_object_lookup(dev, file_priv, args->handle);
243 obj_priv = obj->driver_private;
245 mutex_lock(&dev->struct_mutex);
247 if (args->tiling_mode == I915_TILING_NONE) {
248 obj_priv->tiling_mode = I915_TILING_NONE;
249 args->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
251 if (args->tiling_mode == I915_TILING_X)
252 args->swizzle_mode = dev_priv->mm.bit_6_swizzle_x;
254 args->swizzle_mode = dev_priv->mm.bit_6_swizzle_y;
255 /* If we can't handle the swizzling, make it untiled. */
256 if (args->swizzle_mode == I915_BIT_6_SWIZZLE_UNKNOWN) {
257 args->tiling_mode = I915_TILING_NONE;
258 args->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
261 obj_priv->tiling_mode = args->tiling_mode;
263 mutex_unlock(&dev->struct_mutex);
265 drm_gem_object_unreference(obj);
271 * Returns the current tiling mode and required bit 6 swizzling for the object.
274 i915_gem_get_tiling(struct drm_device *dev, void *data,
275 struct drm_file *file_priv)
277 struct drm_i915_gem_get_tiling *args = data;
278 drm_i915_private_t *dev_priv = dev->dev_private;
279 struct drm_gem_object *obj;
280 struct drm_i915_gem_object *obj_priv;
282 obj = drm_gem_object_lookup(dev, file_priv, args->handle);
285 obj_priv = obj->driver_private;
287 mutex_lock(&dev->struct_mutex);
289 args->tiling_mode = obj_priv->tiling_mode;
290 switch (obj_priv->tiling_mode) {
292 args->swizzle_mode = dev_priv->mm.bit_6_swizzle_x;
295 args->swizzle_mode = dev_priv->mm.bit_6_swizzle_y;
297 case I915_TILING_NONE:
298 args->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
301 DRM_ERROR("unknown tiling mode\n");
304 mutex_unlock(&dev->struct_mutex);
306 drm_gem_object_unreference(obj);