Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1 | /* savage_bci.c -- BCI support for Savage |
| 2 | * |
| 3 | * Copyright 2004 Felix Kuehling |
| 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 "Software"), |
| 8 | * to deal in the Software without restriction, including without limitation |
| 9 | * the rights to use, copy, modify, merge, publish, distribute, sub license, |
| 10 | * and/or sell copies of the Software, and to permit persons to whom the |
| 11 | * Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice (including the |
| 14 | * next paragraph) shall be included in all copies or substantial portions |
| 15 | * of the Software. |
| 16 | * |
| 17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 18 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 19 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| 20 | * NON-INFRINGEMENT. IN NO EVENT SHALL FELIX KUEHLING BE LIABLE FOR |
| 21 | * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF |
| 22 | * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| 23 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 24 | */ |
David Howells | 760285e | 2012-10-02 18:01:07 +0100 | [diff] [blame] | 25 | #include <drm/drmP.h> |
| 26 | #include <drm/savage_drm.h> |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 27 | #include "savage_drv.h" |
| 28 | |
| 29 | /* Need a long timeout for shadow status updates can take a while |
| 30 | * and so can waiting for events when the queue is full. */ |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 31 | #define SAVAGE_DEFAULT_USEC_TIMEOUT 1000000 /* 1s */ |
| 32 | #define SAVAGE_EVENT_USEC_TIMEOUT 5000000 /* 5s */ |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 33 | #define SAVAGE_FREELIST_DEBUG 0 |
| 34 | |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 35 | static int savage_do_cleanup_bci(struct drm_device *dev); |
Dave Airlie | ce60fe0 | 2006-02-02 19:21:38 +1100 | [diff] [blame] | 36 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 37 | static int |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 38 | savage_bci_wait_fifo_shadow(drm_savage_private_t * dev_priv, unsigned int n) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 39 | { |
| 40 | uint32_t mask = dev_priv->status_used_mask; |
| 41 | uint32_t threshold = dev_priv->bci_threshold_hi; |
| 42 | uint32_t status; |
| 43 | int i; |
| 44 | |
| 45 | #if SAVAGE_BCI_DEBUG |
| 46 | if (n > dev_priv->cob_size + SAVAGE_BCI_FIFO_SIZE - threshold) |
| 47 | DRM_ERROR("Trying to emit %d words " |
| 48 | "(more than guaranteed space in COB)\n", n); |
| 49 | #endif |
| 50 | |
| 51 | for (i = 0; i < SAVAGE_DEFAULT_USEC_TIMEOUT; i++) { |
Daniel Vetter | 85b2331 | 2013-12-11 11:34:45 +0100 | [diff] [blame] | 52 | mb(); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 53 | status = dev_priv->status_ptr[0]; |
| 54 | if ((status & mask) < threshold) |
| 55 | return 0; |
| 56 | DRM_UDELAY(1); |
| 57 | } |
| 58 | |
| 59 | #if SAVAGE_BCI_DEBUG |
| 60 | DRM_ERROR("failed!\n"); |
| 61 | DRM_INFO(" status=0x%08x, threshold=0x%08x\n", status, threshold); |
| 62 | #endif |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 63 | return -EBUSY; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 64 | } |
| 65 | |
| 66 | static int |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 67 | savage_bci_wait_fifo_s3d(drm_savage_private_t * dev_priv, unsigned int n) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 68 | { |
| 69 | uint32_t maxUsed = dev_priv->cob_size + SAVAGE_BCI_FIFO_SIZE - n; |
| 70 | uint32_t status; |
| 71 | int i; |
| 72 | |
| 73 | for (i = 0; i < SAVAGE_DEFAULT_USEC_TIMEOUT; i++) { |
| 74 | status = SAVAGE_READ(SAVAGE_STATUS_WORD0); |
| 75 | if ((status & SAVAGE_FIFO_USED_MASK_S3D) <= maxUsed) |
| 76 | return 0; |
| 77 | DRM_UDELAY(1); |
| 78 | } |
| 79 | |
| 80 | #if SAVAGE_BCI_DEBUG |
| 81 | DRM_ERROR("failed!\n"); |
| 82 | DRM_INFO(" status=0x%08x\n", status); |
| 83 | #endif |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 84 | return -EBUSY; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | static int |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 88 | savage_bci_wait_fifo_s4(drm_savage_private_t * dev_priv, unsigned int n) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 89 | { |
| 90 | uint32_t maxUsed = dev_priv->cob_size + SAVAGE_BCI_FIFO_SIZE - n; |
| 91 | uint32_t status; |
| 92 | int i; |
| 93 | |
| 94 | for (i = 0; i < SAVAGE_DEFAULT_USEC_TIMEOUT; i++) { |
| 95 | status = SAVAGE_READ(SAVAGE_ALT_STATUS_WORD0); |
| 96 | if ((status & SAVAGE_FIFO_USED_MASK_S4) <= maxUsed) |
| 97 | return 0; |
| 98 | DRM_UDELAY(1); |
| 99 | } |
| 100 | |
| 101 | #if SAVAGE_BCI_DEBUG |
| 102 | DRM_ERROR("failed!\n"); |
| 103 | DRM_INFO(" status=0x%08x\n", status); |
| 104 | #endif |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 105 | return -EBUSY; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 106 | } |
| 107 | |
| 108 | /* |
| 109 | * Waiting for events. |
| 110 | * |
| 111 | * The BIOSresets the event tag to 0 on mode changes. Therefore we |
| 112 | * never emit 0 to the event tag. If we find a 0 event tag we know the |
| 113 | * BIOS stomped on it and return success assuming that the BIOS waited |
| 114 | * for engine idle. |
| 115 | * |
| 116 | * Note: if the Xserver uses the event tag it has to follow the same |
| 117 | * rule. Otherwise there may be glitches every 2^16 events. |
| 118 | */ |
| 119 | static int |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 120 | savage_bci_wait_event_shadow(drm_savage_private_t * dev_priv, uint16_t e) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 121 | { |
| 122 | uint32_t status; |
| 123 | int i; |
| 124 | |
| 125 | for (i = 0; i < SAVAGE_EVENT_USEC_TIMEOUT; i++) { |
Daniel Vetter | 85b2331 | 2013-12-11 11:34:45 +0100 | [diff] [blame] | 126 | mb(); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 127 | status = dev_priv->status_ptr[1]; |
| 128 | if ((((status & 0xffff) - e) & 0xffff) <= 0x7fff || |
| 129 | (status & 0xffff) == 0) |
| 130 | return 0; |
| 131 | DRM_UDELAY(1); |
| 132 | } |
| 133 | |
| 134 | #if SAVAGE_BCI_DEBUG |
| 135 | DRM_ERROR("failed!\n"); |
| 136 | DRM_INFO(" status=0x%08x, e=0x%04x\n", status, e); |
| 137 | #endif |
| 138 | |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 139 | return -EBUSY; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 140 | } |
| 141 | |
| 142 | static int |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 143 | savage_bci_wait_event_reg(drm_savage_private_t * dev_priv, uint16_t e) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 144 | { |
| 145 | uint32_t status; |
| 146 | int i; |
| 147 | |
| 148 | for (i = 0; i < SAVAGE_EVENT_USEC_TIMEOUT; i++) { |
| 149 | status = SAVAGE_READ(SAVAGE_STATUS_WORD1); |
| 150 | if ((((status & 0xffff) - e) & 0xffff) <= 0x7fff || |
| 151 | (status & 0xffff) == 0) |
| 152 | return 0; |
| 153 | DRM_UDELAY(1); |
| 154 | } |
| 155 | |
| 156 | #if SAVAGE_BCI_DEBUG |
| 157 | DRM_ERROR("failed!\n"); |
| 158 | DRM_INFO(" status=0x%08x, e=0x%04x\n", status, e); |
| 159 | #endif |
| 160 | |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 161 | return -EBUSY; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 162 | } |
| 163 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 164 | uint16_t savage_bci_emit_event(drm_savage_private_t * dev_priv, |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 165 | unsigned int flags) |
| 166 | { |
| 167 | uint16_t count; |
| 168 | BCI_LOCALS; |
| 169 | |
| 170 | if (dev_priv->status_ptr) { |
| 171 | /* coordinate with Xserver */ |
| 172 | count = dev_priv->status_ptr[1023]; |
| 173 | if (count < dev_priv->event_counter) |
| 174 | dev_priv->event_wrap++; |
| 175 | } else { |
| 176 | count = dev_priv->event_counter; |
| 177 | } |
| 178 | count = (count + 1) & 0xffff; |
| 179 | if (count == 0) { |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 180 | count++; /* See the comment above savage_wait_event_*. */ |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 181 | dev_priv->event_wrap++; |
| 182 | } |
| 183 | dev_priv->event_counter = count; |
| 184 | if (dev_priv->status_ptr) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 185 | dev_priv->status_ptr[1023] = (uint32_t) count; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 186 | |
| 187 | if ((flags & (SAVAGE_WAIT_2D | SAVAGE_WAIT_3D))) { |
| 188 | unsigned int wait_cmd = BCI_CMD_WAIT; |
| 189 | if ((flags & SAVAGE_WAIT_2D)) |
| 190 | wait_cmd |= BCI_CMD_WAIT_2D; |
| 191 | if ((flags & SAVAGE_WAIT_3D)) |
| 192 | wait_cmd |= BCI_CMD_WAIT_3D; |
| 193 | BEGIN_BCI(2); |
| 194 | BCI_WRITE(wait_cmd); |
| 195 | } else { |
| 196 | BEGIN_BCI(1); |
| 197 | } |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 198 | BCI_WRITE(BCI_CMD_UPDATE_EVENT_TAG | (uint32_t) count); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 199 | |
| 200 | return count; |
| 201 | } |
| 202 | |
| 203 | /* |
| 204 | * Freelist management |
| 205 | */ |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 206 | static int savage_freelist_init(struct drm_device * dev) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 207 | { |
| 208 | drm_savage_private_t *dev_priv = dev->dev_private; |
Dave Airlie | cdd55a2 | 2007-07-11 16:32:08 +1000 | [diff] [blame] | 209 | struct drm_device_dma *dma = dev->dma; |
Dave Airlie | 056219e | 2007-07-11 16:17:42 +1000 | [diff] [blame] | 210 | struct drm_buf *buf; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 211 | drm_savage_buf_priv_t *entry; |
| 212 | int i; |
| 213 | DRM_DEBUG("count=%d\n", dma->buf_count); |
| 214 | |
| 215 | dev_priv->head.next = &dev_priv->tail; |
| 216 | dev_priv->head.prev = NULL; |
| 217 | dev_priv->head.buf = NULL; |
| 218 | |
| 219 | dev_priv->tail.next = NULL; |
| 220 | dev_priv->tail.prev = &dev_priv->head; |
| 221 | dev_priv->tail.buf = NULL; |
| 222 | |
| 223 | for (i = 0; i < dma->buf_count; i++) { |
| 224 | buf = dma->buflist[i]; |
| 225 | entry = buf->dev_private; |
| 226 | |
| 227 | SET_AGE(&entry->age, 0, 0); |
| 228 | entry->buf = buf; |
| 229 | |
| 230 | entry->next = dev_priv->head.next; |
| 231 | entry->prev = &dev_priv->head; |
| 232 | dev_priv->head.next->prev = entry; |
| 233 | dev_priv->head.next = entry; |
| 234 | } |
| 235 | |
| 236 | return 0; |
| 237 | } |
| 238 | |
Dave Airlie | 056219e | 2007-07-11 16:17:42 +1000 | [diff] [blame] | 239 | static struct drm_buf *savage_freelist_get(struct drm_device * dev) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 240 | { |
| 241 | drm_savage_private_t *dev_priv = dev->dev_private; |
| 242 | drm_savage_buf_priv_t *tail = dev_priv->tail.prev; |
| 243 | uint16_t event; |
| 244 | unsigned int wrap; |
| 245 | DRM_DEBUG("\n"); |
| 246 | |
| 247 | UPDATE_EVENT_COUNTER(); |
| 248 | if (dev_priv->status_ptr) |
| 249 | event = dev_priv->status_ptr[1] & 0xffff; |
| 250 | else |
| 251 | event = SAVAGE_READ(SAVAGE_STATUS_WORD1) & 0xffff; |
| 252 | wrap = dev_priv->event_wrap; |
| 253 | if (event > dev_priv->event_counter) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 254 | wrap--; /* hardware hasn't passed the last wrap yet */ |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 255 | |
| 256 | DRM_DEBUG(" tail=0x%04x %d\n", tail->age.event, tail->age.wrap); |
| 257 | DRM_DEBUG(" head=0x%04x %d\n", event, wrap); |
| 258 | |
| 259 | if (tail->buf && (TEST_AGE(&tail->age, event, wrap) || event == 0)) { |
| 260 | drm_savage_buf_priv_t *next = tail->next; |
| 261 | drm_savage_buf_priv_t *prev = tail->prev; |
| 262 | prev->next = next; |
| 263 | next->prev = prev; |
| 264 | tail->next = tail->prev = NULL; |
| 265 | return tail->buf; |
| 266 | } |
| 267 | |
| 268 | DRM_DEBUG("returning NULL, tail->buf=%p!\n", tail->buf); |
| 269 | return NULL; |
| 270 | } |
| 271 | |
Dave Airlie | 056219e | 2007-07-11 16:17:42 +1000 | [diff] [blame] | 272 | void savage_freelist_put(struct drm_device * dev, struct drm_buf * buf) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 273 | { |
| 274 | drm_savage_private_t *dev_priv = dev->dev_private; |
| 275 | drm_savage_buf_priv_t *entry = buf->dev_private, *prev, *next; |
| 276 | |
| 277 | DRM_DEBUG("age=0x%04x wrap=%d\n", entry->age.event, entry->age.wrap); |
| 278 | |
| 279 | if (entry->next != NULL || entry->prev != NULL) { |
| 280 | DRM_ERROR("entry already on freelist.\n"); |
| 281 | return; |
| 282 | } |
| 283 | |
| 284 | prev = &dev_priv->head; |
| 285 | next = prev->next; |
| 286 | prev->next = entry; |
| 287 | next->prev = entry; |
| 288 | entry->prev = prev; |
| 289 | entry->next = next; |
| 290 | } |
| 291 | |
| 292 | /* |
| 293 | * Command DMA |
| 294 | */ |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 295 | static int savage_dma_init(drm_savage_private_t * dev_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 296 | { |
| 297 | unsigned int i; |
| 298 | |
| 299 | dev_priv->nr_dma_pages = dev_priv->cmd_dma->size / |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 300 | (SAVAGE_DMA_PAGE_SIZE * 4); |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 301 | dev_priv->dma_pages = kmalloc(sizeof(drm_savage_dma_page_t) * |
| 302 | dev_priv->nr_dma_pages, GFP_KERNEL); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 303 | if (dev_priv->dma_pages == NULL) |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 304 | return -ENOMEM; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 305 | |
| 306 | for (i = 0; i < dev_priv->nr_dma_pages; ++i) { |
| 307 | SET_AGE(&dev_priv->dma_pages[i].age, 0, 0); |
| 308 | dev_priv->dma_pages[i].used = 0; |
| 309 | dev_priv->dma_pages[i].flushed = 0; |
| 310 | } |
| 311 | SET_AGE(&dev_priv->last_dma_age, 0, 0); |
| 312 | |
| 313 | dev_priv->first_dma_page = 0; |
| 314 | dev_priv->current_dma_page = 0; |
| 315 | |
| 316 | return 0; |
| 317 | } |
| 318 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 319 | void savage_dma_reset(drm_savage_private_t * dev_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 320 | { |
| 321 | uint16_t event; |
| 322 | unsigned int wrap, i; |
| 323 | event = savage_bci_emit_event(dev_priv, 0); |
| 324 | wrap = dev_priv->event_wrap; |
| 325 | for (i = 0; i < dev_priv->nr_dma_pages; ++i) { |
| 326 | SET_AGE(&dev_priv->dma_pages[i].age, event, wrap); |
| 327 | dev_priv->dma_pages[i].used = 0; |
| 328 | dev_priv->dma_pages[i].flushed = 0; |
| 329 | } |
| 330 | SET_AGE(&dev_priv->last_dma_age, event, wrap); |
| 331 | dev_priv->first_dma_page = dev_priv->current_dma_page = 0; |
| 332 | } |
| 333 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 334 | void savage_dma_wait(drm_savage_private_t * dev_priv, unsigned int page) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 335 | { |
| 336 | uint16_t event; |
| 337 | unsigned int wrap; |
| 338 | |
| 339 | /* Faked DMA buffer pages don't age. */ |
| 340 | if (dev_priv->cmd_dma == &dev_priv->fake_dma) |
| 341 | return; |
| 342 | |
| 343 | UPDATE_EVENT_COUNTER(); |
| 344 | if (dev_priv->status_ptr) |
| 345 | event = dev_priv->status_ptr[1] & 0xffff; |
| 346 | else |
| 347 | event = SAVAGE_READ(SAVAGE_STATUS_WORD1) & 0xffff; |
| 348 | wrap = dev_priv->event_wrap; |
| 349 | if (event > dev_priv->event_counter) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 350 | wrap--; /* hardware hasn't passed the last wrap yet */ |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 351 | |
| 352 | if (dev_priv->dma_pages[page].age.wrap > wrap || |
| 353 | (dev_priv->dma_pages[page].age.wrap == wrap && |
| 354 | dev_priv->dma_pages[page].age.event > event)) { |
| 355 | if (dev_priv->wait_evnt(dev_priv, |
| 356 | dev_priv->dma_pages[page].age.event) |
| 357 | < 0) |
| 358 | DRM_ERROR("wait_evnt failed!\n"); |
| 359 | } |
| 360 | } |
| 361 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 362 | uint32_t *savage_dma_alloc(drm_savage_private_t * dev_priv, unsigned int n) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 363 | { |
| 364 | unsigned int cur = dev_priv->current_dma_page; |
| 365 | unsigned int rest = SAVAGE_DMA_PAGE_SIZE - |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 366 | dev_priv->dma_pages[cur].used; |
| 367 | unsigned int nr_pages = (n - rest + SAVAGE_DMA_PAGE_SIZE - 1) / |
| 368 | SAVAGE_DMA_PAGE_SIZE; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 369 | uint32_t *dma_ptr; |
| 370 | unsigned int i; |
| 371 | |
| 372 | DRM_DEBUG("cur=%u, cur->used=%u, n=%u, rest=%u, nr_pages=%u\n", |
| 373 | cur, dev_priv->dma_pages[cur].used, n, rest, nr_pages); |
| 374 | |
| 375 | if (cur + nr_pages < dev_priv->nr_dma_pages) { |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 376 | dma_ptr = (uint32_t *) dev_priv->cmd_dma->handle + |
| 377 | cur * SAVAGE_DMA_PAGE_SIZE + dev_priv->dma_pages[cur].used; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 378 | if (n < rest) |
| 379 | rest = n; |
| 380 | dev_priv->dma_pages[cur].used += rest; |
| 381 | n -= rest; |
| 382 | cur++; |
| 383 | } else { |
| 384 | dev_priv->dma_flush(dev_priv); |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 385 | nr_pages = |
| 386 | (n + SAVAGE_DMA_PAGE_SIZE - 1) / SAVAGE_DMA_PAGE_SIZE; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 387 | for (i = cur; i < dev_priv->nr_dma_pages; ++i) { |
| 388 | dev_priv->dma_pages[i].age = dev_priv->last_dma_age; |
| 389 | dev_priv->dma_pages[i].used = 0; |
| 390 | dev_priv->dma_pages[i].flushed = 0; |
| 391 | } |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 392 | dma_ptr = (uint32_t *) dev_priv->cmd_dma->handle; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 393 | dev_priv->first_dma_page = cur = 0; |
| 394 | } |
| 395 | for (i = cur; nr_pages > 0; ++i, --nr_pages) { |
| 396 | #if SAVAGE_DMA_DEBUG |
| 397 | if (dev_priv->dma_pages[i].used) { |
| 398 | DRM_ERROR("unflushed page %u: used=%u\n", |
| 399 | i, dev_priv->dma_pages[i].used); |
| 400 | } |
| 401 | #endif |
| 402 | if (n > SAVAGE_DMA_PAGE_SIZE) |
| 403 | dev_priv->dma_pages[i].used = SAVAGE_DMA_PAGE_SIZE; |
| 404 | else |
| 405 | dev_priv->dma_pages[i].used = n; |
| 406 | n -= SAVAGE_DMA_PAGE_SIZE; |
| 407 | } |
| 408 | dev_priv->current_dma_page = --i; |
| 409 | |
| 410 | DRM_DEBUG("cur=%u, cur->used=%u, n=%u\n", |
| 411 | i, dev_priv->dma_pages[i].used, n); |
| 412 | |
| 413 | savage_dma_wait(dev_priv, dev_priv->current_dma_page); |
| 414 | |
| 415 | return dma_ptr; |
| 416 | } |
| 417 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 418 | static void savage_dma_flush(drm_savage_private_t * dev_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 419 | { |
| 420 | unsigned int first = dev_priv->first_dma_page; |
| 421 | unsigned int cur = dev_priv->current_dma_page; |
| 422 | uint16_t event; |
| 423 | unsigned int wrap, pad, align, len, i; |
| 424 | unsigned long phys_addr; |
| 425 | BCI_LOCALS; |
| 426 | |
| 427 | if (first == cur && |
| 428 | dev_priv->dma_pages[cur].used == dev_priv->dma_pages[cur].flushed) |
| 429 | return; |
| 430 | |
| 431 | /* pad length to multiples of 2 entries |
| 432 | * align start of next DMA block to multiles of 8 entries */ |
| 433 | pad = -dev_priv->dma_pages[cur].used & 1; |
| 434 | align = -(dev_priv->dma_pages[cur].used + pad) & 7; |
| 435 | |
| 436 | DRM_DEBUG("first=%u, cur=%u, first->flushed=%u, cur->used=%u, " |
| 437 | "pad=%u, align=%u\n", |
| 438 | first, cur, dev_priv->dma_pages[first].flushed, |
| 439 | dev_priv->dma_pages[cur].used, pad, align); |
| 440 | |
| 441 | /* pad with noops */ |
| 442 | if (pad) { |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 443 | uint32_t *dma_ptr = (uint32_t *) dev_priv->cmd_dma->handle + |
| 444 | cur * SAVAGE_DMA_PAGE_SIZE + dev_priv->dma_pages[cur].used; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 445 | dev_priv->dma_pages[cur].used += pad; |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 446 | while (pad != 0) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 447 | *dma_ptr++ = BCI_CMD_WAIT; |
| 448 | pad--; |
| 449 | } |
| 450 | } |
| 451 | |
Daniel Vetter | 85b2331 | 2013-12-11 11:34:45 +0100 | [diff] [blame] | 452 | mb(); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 453 | |
| 454 | /* do flush ... */ |
| 455 | phys_addr = dev_priv->cmd_dma->offset + |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 456 | (first * SAVAGE_DMA_PAGE_SIZE + |
| 457 | dev_priv->dma_pages[first].flushed) * 4; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 458 | len = (cur - first) * SAVAGE_DMA_PAGE_SIZE + |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 459 | dev_priv->dma_pages[cur].used - dev_priv->dma_pages[first].flushed; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 460 | |
| 461 | DRM_DEBUG("phys_addr=%lx, len=%u\n", |
| 462 | phys_addr | dev_priv->dma_type, len); |
| 463 | |
| 464 | BEGIN_BCI(3); |
| 465 | BCI_SET_REGISTERS(SAVAGE_DMABUFADDR, 1); |
| 466 | BCI_WRITE(phys_addr | dev_priv->dma_type); |
| 467 | BCI_DMA(len); |
| 468 | |
| 469 | /* fix alignment of the start of the next block */ |
| 470 | dev_priv->dma_pages[cur].used += align; |
| 471 | |
| 472 | /* age DMA pages */ |
| 473 | event = savage_bci_emit_event(dev_priv, 0); |
| 474 | wrap = dev_priv->event_wrap; |
| 475 | for (i = first; i < cur; ++i) { |
| 476 | SET_AGE(&dev_priv->dma_pages[i].age, event, wrap); |
| 477 | dev_priv->dma_pages[i].used = 0; |
| 478 | dev_priv->dma_pages[i].flushed = 0; |
| 479 | } |
| 480 | /* age the current page only when it's full */ |
| 481 | if (dev_priv->dma_pages[cur].used == SAVAGE_DMA_PAGE_SIZE) { |
| 482 | SET_AGE(&dev_priv->dma_pages[cur].age, event, wrap); |
| 483 | dev_priv->dma_pages[cur].used = 0; |
| 484 | dev_priv->dma_pages[cur].flushed = 0; |
| 485 | /* advance to next page */ |
| 486 | cur++; |
| 487 | if (cur == dev_priv->nr_dma_pages) |
| 488 | cur = 0; |
| 489 | dev_priv->first_dma_page = dev_priv->current_dma_page = cur; |
| 490 | } else { |
| 491 | dev_priv->first_dma_page = cur; |
| 492 | dev_priv->dma_pages[cur].flushed = dev_priv->dma_pages[i].used; |
| 493 | } |
| 494 | SET_AGE(&dev_priv->last_dma_age, event, wrap); |
| 495 | |
| 496 | DRM_DEBUG("first=cur=%u, cur->used=%u, cur->flushed=%u\n", cur, |
| 497 | dev_priv->dma_pages[cur].used, |
| 498 | dev_priv->dma_pages[cur].flushed); |
| 499 | } |
| 500 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 501 | static void savage_fake_dma_flush(drm_savage_private_t * dev_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 502 | { |
| 503 | unsigned int i, j; |
| 504 | BCI_LOCALS; |
| 505 | |
| 506 | if (dev_priv->first_dma_page == dev_priv->current_dma_page && |
| 507 | dev_priv->dma_pages[dev_priv->current_dma_page].used == 0) |
| 508 | return; |
| 509 | |
| 510 | DRM_DEBUG("first=%u, cur=%u, cur->used=%u\n", |
| 511 | dev_priv->first_dma_page, dev_priv->current_dma_page, |
| 512 | dev_priv->dma_pages[dev_priv->current_dma_page].used); |
| 513 | |
| 514 | for (i = dev_priv->first_dma_page; |
| 515 | i <= dev_priv->current_dma_page && dev_priv->dma_pages[i].used; |
| 516 | ++i) { |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 517 | uint32_t *dma_ptr = (uint32_t *) dev_priv->cmd_dma->handle + |
| 518 | i * SAVAGE_DMA_PAGE_SIZE; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 519 | #if SAVAGE_DMA_DEBUG |
| 520 | /* Sanity check: all pages except the last one must be full. */ |
| 521 | if (i < dev_priv->current_dma_page && |
| 522 | dev_priv->dma_pages[i].used != SAVAGE_DMA_PAGE_SIZE) { |
| 523 | DRM_ERROR("partial DMA page %u: used=%u", |
| 524 | i, dev_priv->dma_pages[i].used); |
| 525 | } |
| 526 | #endif |
| 527 | BEGIN_BCI(dev_priv->dma_pages[i].used); |
| 528 | for (j = 0; j < dev_priv->dma_pages[i].used; ++j) { |
| 529 | BCI_WRITE(dma_ptr[j]); |
| 530 | } |
| 531 | dev_priv->dma_pages[i].used = 0; |
| 532 | } |
| 533 | |
| 534 | /* reset to first page */ |
| 535 | dev_priv->first_dma_page = dev_priv->current_dma_page = 0; |
| 536 | } |
| 537 | |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 538 | int savage_driver_load(struct drm_device *dev, unsigned long chipset) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 539 | { |
| 540 | drm_savage_private_t *dev_priv; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 541 | |
Julia Lawall | 6ebc22e | 2010-05-13 21:58:56 +0200 | [diff] [blame] | 542 | dev_priv = kzalloc(sizeof(drm_savage_private_t), GFP_KERNEL); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 543 | if (dev_priv == NULL) |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 544 | return -ENOMEM; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 545 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 546 | dev->dev_private = (void *)dev_priv; |
Dave Airlie | 22eae94 | 2005-11-10 22:16:34 +1100 | [diff] [blame] | 547 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 548 | dev_priv->chipset = (enum savage_family)chipset; |
| 549 | |
Florian Zumbiehl | df86b57 | 2012-10-02 12:20:37 +0000 | [diff] [blame] | 550 | pci_set_master(dev->pdev); |
| 551 | |
Dave Airlie | 22eae94 | 2005-11-10 22:16:34 +1100 | [diff] [blame] | 552 | return 0; |
| 553 | } |
| 554 | |
| 555 | |
| 556 | /* |
Uwe Kleine-König | 421f91d | 2010-06-11 12:17:00 +0200 | [diff] [blame] | 557 | * Initialize mappings. On Savage4 and SavageIX the alignment |
Dave Airlie | 22eae94 | 2005-11-10 22:16:34 +1100 | [diff] [blame] | 558 | * and size of the aperture is not suitable for automatic MTRR setup |
| 559 | * in drm_addmap. Therefore we add them manually before the maps are |
| 560 | * initialized, and tear them down on last close. |
| 561 | */ |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 562 | int savage_driver_firstopen(struct drm_device *dev) |
Dave Airlie | 22eae94 | 2005-11-10 22:16:34 +1100 | [diff] [blame] | 563 | { |
| 564 | drm_savage_private_t *dev_priv = dev->dev_private; |
| 565 | unsigned long mmio_base, fb_base, fb_size, aperture_base; |
| 566 | /* fb_rsrc and aper_rsrc aren't really used currently, but still exist |
| 567 | * in case we decide we need information on the BAR for BSD in the |
| 568 | * future. |
| 569 | */ |
| 570 | unsigned int fb_rsrc, aper_rsrc; |
| 571 | int ret = 0; |
| 572 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 573 | if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) { |
| 574 | fb_rsrc = 0; |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 575 | fb_base = pci_resource_start(dev->pdev, 0); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 576 | fb_size = SAVAGE_FB_SIZE_S3; |
| 577 | mmio_base = fb_base + SAVAGE_FB_SIZE_S3; |
| 578 | aper_rsrc = 0; |
| 579 | aperture_base = fb_base + SAVAGE_APERTURE_OFFSET; |
| 580 | /* this should always be true */ |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 581 | if (pci_resource_len(dev->pdev, 0) == 0x08000000) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 582 | /* Don't make MMIO write-cobining! We need 3 |
| 583 | * MTRRs. */ |
Andy Lutomirski | 247d36d | 2013-05-13 23:58:41 +0000 | [diff] [blame] | 584 | dev_priv->mtrr_handles[0] = |
| 585 | arch_phys_wc_add(fb_base, 0x01000000); |
| 586 | dev_priv->mtrr_handles[1] = |
| 587 | arch_phys_wc_add(fb_base + 0x02000000, |
| 588 | 0x02000000); |
| 589 | dev_priv->mtrr_handles[2] = |
| 590 | arch_phys_wc_add(fb_base + 0x04000000, |
| 591 | 0x04000000); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 592 | } else { |
Benjamin Herrenschmidt | d883f7f | 2009-02-02 16:55:45 +1100 | [diff] [blame] | 593 | DRM_ERROR("strange pci_resource_len %08llx\n", |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 594 | (unsigned long long) |
| 595 | pci_resource_len(dev->pdev, 0)); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 596 | } |
Dave Airlie | 22eae94 | 2005-11-10 22:16:34 +1100 | [diff] [blame] | 597 | } else if (dev_priv->chipset != S3_SUPERSAVAGE && |
| 598 | dev_priv->chipset != S3_SAVAGE2000) { |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 599 | mmio_base = pci_resource_start(dev->pdev, 0); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 600 | fb_rsrc = 1; |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 601 | fb_base = pci_resource_start(dev->pdev, 1); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 602 | fb_size = SAVAGE_FB_SIZE_S4; |
| 603 | aper_rsrc = 1; |
| 604 | aperture_base = fb_base + SAVAGE_APERTURE_OFFSET; |
| 605 | /* this should always be true */ |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 606 | if (pci_resource_len(dev->pdev, 1) == 0x08000000) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 607 | /* Can use one MTRR to cover both fb and |
| 608 | * aperture. */ |
Andy Lutomirski | 247d36d | 2013-05-13 23:58:41 +0000 | [diff] [blame] | 609 | dev_priv->mtrr_handles[0] = |
| 610 | arch_phys_wc_add(fb_base, |
| 611 | 0x08000000); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 612 | } else { |
Benjamin Herrenschmidt | d883f7f | 2009-02-02 16:55:45 +1100 | [diff] [blame] | 613 | DRM_ERROR("strange pci_resource_len %08llx\n", |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 614 | (unsigned long long) |
| 615 | pci_resource_len(dev->pdev, 1)); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 616 | } |
| 617 | } else { |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 618 | mmio_base = pci_resource_start(dev->pdev, 0); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 619 | fb_rsrc = 1; |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 620 | fb_base = pci_resource_start(dev->pdev, 1); |
| 621 | fb_size = pci_resource_len(dev->pdev, 1); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 622 | aper_rsrc = 2; |
Jordan Crouse | 01d73a6 | 2010-05-27 13:40:24 -0600 | [diff] [blame] | 623 | aperture_base = pci_resource_start(dev->pdev, 2); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 624 | /* Automatic MTRR setup will do the right thing. */ |
| 625 | } |
| 626 | |
| 627 | ret = drm_addmap(dev, mmio_base, SAVAGE_MMIO_SIZE, _DRM_REGISTERS, |
| 628 | _DRM_READ_ONLY, &dev_priv->mmio); |
| 629 | if (ret) |
| 630 | return ret; |
| 631 | |
| 632 | ret = drm_addmap(dev, fb_base, fb_size, _DRM_FRAME_BUFFER, |
| 633 | _DRM_WRITE_COMBINING, &dev_priv->fb); |
| 634 | if (ret) |
| 635 | return ret; |
| 636 | |
| 637 | ret = drm_addmap(dev, aperture_base, SAVAGE_APERTURE_SIZE, |
| 638 | _DRM_FRAME_BUFFER, _DRM_WRITE_COMBINING, |
| 639 | &dev_priv->aperture); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 640 | return ret; |
| 641 | } |
| 642 | |
| 643 | /* |
| 644 | * Delete MTRRs and free device-private data. |
| 645 | */ |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 646 | void savage_driver_lastclose(struct drm_device *dev) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 647 | { |
| 648 | drm_savage_private_t *dev_priv = dev->dev_private; |
| 649 | int i; |
| 650 | |
Andy Lutomirski | 247d36d | 2013-05-13 23:58:41 +0000 | [diff] [blame] | 651 | for (i = 0; i < 3; ++i) { |
| 652 | arch_phys_wc_del(dev_priv->mtrr_handles[i]); |
| 653 | dev_priv->mtrr_handles[i] = 0; |
| 654 | } |
Dave Airlie | 22eae94 | 2005-11-10 22:16:34 +1100 | [diff] [blame] | 655 | } |
| 656 | |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 657 | int savage_driver_unload(struct drm_device *dev) |
Dave Airlie | 22eae94 | 2005-11-10 22:16:34 +1100 | [diff] [blame] | 658 | { |
| 659 | drm_savage_private_t *dev_priv = dev->dev_private; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 660 | |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 661 | kfree(dev_priv); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 662 | |
| 663 | return 0; |
| 664 | } |
| 665 | |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 666 | static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 667 | { |
| 668 | drm_savage_private_t *dev_priv = dev->dev_private; |
| 669 | |
| 670 | if (init->fb_bpp != 16 && init->fb_bpp != 32) { |
| 671 | DRM_ERROR("invalid frame buffer bpp %d!\n", init->fb_bpp); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 672 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 673 | } |
| 674 | if (init->depth_bpp != 16 && init->depth_bpp != 32) { |
| 675 | DRM_ERROR("invalid depth buffer bpp %d!\n", init->fb_bpp); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 676 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 677 | } |
| 678 | if (init->dma_type != SAVAGE_DMA_AGP && |
| 679 | init->dma_type != SAVAGE_DMA_PCI) { |
| 680 | DRM_ERROR("invalid dma memory type %d!\n", init->dma_type); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 681 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 682 | } |
| 683 | |
| 684 | dev_priv->cob_size = init->cob_size; |
| 685 | dev_priv->bci_threshold_lo = init->bci_threshold_lo; |
| 686 | dev_priv->bci_threshold_hi = init->bci_threshold_hi; |
| 687 | dev_priv->dma_type = init->dma_type; |
| 688 | |
| 689 | dev_priv->fb_bpp = init->fb_bpp; |
| 690 | dev_priv->front_offset = init->front_offset; |
| 691 | dev_priv->front_pitch = init->front_pitch; |
| 692 | dev_priv->back_offset = init->back_offset; |
| 693 | dev_priv->back_pitch = init->back_pitch; |
| 694 | dev_priv->depth_bpp = init->depth_bpp; |
| 695 | dev_priv->depth_offset = init->depth_offset; |
| 696 | dev_priv->depth_pitch = init->depth_pitch; |
| 697 | |
| 698 | dev_priv->texture_offset = init->texture_offset; |
| 699 | dev_priv->texture_size = init->texture_size; |
| 700 | |
Dave Airlie | da509d7 | 2007-05-26 05:04:51 +1000 | [diff] [blame] | 701 | dev_priv->sarea = drm_getsarea(dev); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 702 | if (!dev_priv->sarea) { |
| 703 | DRM_ERROR("could not find sarea!\n"); |
| 704 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 705 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 706 | } |
| 707 | if (init->status_offset != 0) { |
| 708 | dev_priv->status = drm_core_findmap(dev, init->status_offset); |
| 709 | if (!dev_priv->status) { |
| 710 | DRM_ERROR("could not find shadow status region!\n"); |
| 711 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 712 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 713 | } |
| 714 | } else { |
| 715 | dev_priv->status = NULL; |
| 716 | } |
| 717 | if (dev_priv->dma_type == SAVAGE_DMA_AGP && init->buffers_offset) { |
Michael Karcher | 10eee0f | 2006-10-24 21:46:55 +1000 | [diff] [blame] | 718 | dev->agp_buffer_token = init->buffers_offset; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 719 | dev->agp_buffer_map = drm_core_findmap(dev, |
| 720 | init->buffers_offset); |
| 721 | if (!dev->agp_buffer_map) { |
| 722 | DRM_ERROR("could not find DMA buffer region!\n"); |
| 723 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 724 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 725 | } |
| 726 | drm_core_ioremap(dev->agp_buffer_map, dev); |
Dan Carpenter | 10f5ab0 | 2012-05-17 10:09:44 +0300 | [diff] [blame] | 727 | if (!dev->agp_buffer_map->handle) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 728 | DRM_ERROR("failed to ioremap DMA buffer region!\n"); |
| 729 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 730 | return -ENOMEM; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 731 | } |
| 732 | } |
| 733 | if (init->agp_textures_offset) { |
| 734 | dev_priv->agp_textures = |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 735 | drm_core_findmap(dev, init->agp_textures_offset); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 736 | if (!dev_priv->agp_textures) { |
| 737 | DRM_ERROR("could not find agp texture region!\n"); |
| 738 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 739 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 740 | } |
| 741 | } else { |
| 742 | dev_priv->agp_textures = NULL; |
| 743 | } |
| 744 | |
| 745 | if (init->cmd_dma_offset) { |
| 746 | if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) { |
| 747 | DRM_ERROR("command DMA not supported on " |
| 748 | "Savage3D/MX/IX.\n"); |
| 749 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 750 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 751 | } |
| 752 | if (dev->dma && dev->dma->buflist) { |
| 753 | DRM_ERROR("command and vertex DMA not supported " |
| 754 | "at the same time.\n"); |
| 755 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 756 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 757 | } |
| 758 | dev_priv->cmd_dma = drm_core_findmap(dev, init->cmd_dma_offset); |
| 759 | if (!dev_priv->cmd_dma) { |
| 760 | DRM_ERROR("could not find command DMA region!\n"); |
| 761 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 762 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 763 | } |
| 764 | if (dev_priv->dma_type == SAVAGE_DMA_AGP) { |
| 765 | if (dev_priv->cmd_dma->type != _DRM_AGP) { |
| 766 | DRM_ERROR("AGP command DMA region is not a " |
| 767 | "_DRM_AGP map!\n"); |
| 768 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 769 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 770 | } |
| 771 | drm_core_ioremap(dev_priv->cmd_dma, dev); |
| 772 | if (!dev_priv->cmd_dma->handle) { |
| 773 | DRM_ERROR("failed to ioremap command " |
| 774 | "DMA region!\n"); |
| 775 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 776 | return -ENOMEM; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 777 | } |
| 778 | } else if (dev_priv->cmd_dma->type != _DRM_CONSISTENT) { |
| 779 | DRM_ERROR("PCI command DMA region is not a " |
| 780 | "_DRM_CONSISTENT map!\n"); |
| 781 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 782 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 783 | } |
| 784 | } else { |
| 785 | dev_priv->cmd_dma = NULL; |
| 786 | } |
| 787 | |
| 788 | dev_priv->dma_flush = savage_dma_flush; |
| 789 | if (!dev_priv->cmd_dma) { |
| 790 | DRM_DEBUG("falling back to faked command DMA.\n"); |
| 791 | dev_priv->fake_dma.offset = 0; |
| 792 | dev_priv->fake_dma.size = SAVAGE_FAKE_DMA_SIZE; |
| 793 | dev_priv->fake_dma.type = _DRM_SHM; |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 794 | dev_priv->fake_dma.handle = kmalloc(SAVAGE_FAKE_DMA_SIZE, |
| 795 | GFP_KERNEL); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 796 | if (!dev_priv->fake_dma.handle) { |
| 797 | DRM_ERROR("could not allocate faked DMA buffer!\n"); |
| 798 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 799 | return -ENOMEM; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 800 | } |
| 801 | dev_priv->cmd_dma = &dev_priv->fake_dma; |
| 802 | dev_priv->dma_flush = savage_fake_dma_flush; |
| 803 | } |
| 804 | |
| 805 | dev_priv->sarea_priv = |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 806 | (drm_savage_sarea_t *) ((uint8_t *) dev_priv->sarea->handle + |
| 807 | init->sarea_priv_offset); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 808 | |
| 809 | /* setup bitmap descriptors */ |
| 810 | { |
| 811 | unsigned int color_tile_format; |
| 812 | unsigned int depth_tile_format; |
| 813 | unsigned int front_stride, back_stride, depth_stride; |
| 814 | if (dev_priv->chipset <= S3_SAVAGE4) { |
| 815 | color_tile_format = dev_priv->fb_bpp == 16 ? |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 816 | SAVAGE_BD_TILE_16BPP : SAVAGE_BD_TILE_32BPP; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 817 | depth_tile_format = dev_priv->depth_bpp == 16 ? |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 818 | SAVAGE_BD_TILE_16BPP : SAVAGE_BD_TILE_32BPP; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 819 | } else { |
| 820 | color_tile_format = SAVAGE_BD_TILE_DEST; |
| 821 | depth_tile_format = SAVAGE_BD_TILE_DEST; |
| 822 | } |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 823 | front_stride = dev_priv->front_pitch / (dev_priv->fb_bpp / 8); |
| 824 | back_stride = dev_priv->back_pitch / (dev_priv->fb_bpp / 8); |
| 825 | depth_stride = |
| 826 | dev_priv->depth_pitch / (dev_priv->depth_bpp / 8); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 827 | |
| 828 | dev_priv->front_bd = front_stride | SAVAGE_BD_BW_DISABLE | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 829 | (dev_priv->fb_bpp << SAVAGE_BD_BPP_SHIFT) | |
| 830 | (color_tile_format << SAVAGE_BD_TILE_SHIFT); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 831 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 832 | dev_priv->back_bd = back_stride | SAVAGE_BD_BW_DISABLE | |
| 833 | (dev_priv->fb_bpp << SAVAGE_BD_BPP_SHIFT) | |
| 834 | (color_tile_format << SAVAGE_BD_TILE_SHIFT); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 835 | |
| 836 | dev_priv->depth_bd = depth_stride | SAVAGE_BD_BW_DISABLE | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 837 | (dev_priv->depth_bpp << SAVAGE_BD_BPP_SHIFT) | |
| 838 | (depth_tile_format << SAVAGE_BD_TILE_SHIFT); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 839 | } |
| 840 | |
| 841 | /* setup status and bci ptr */ |
| 842 | dev_priv->event_counter = 0; |
| 843 | dev_priv->event_wrap = 0; |
| 844 | dev_priv->bci_ptr = (volatile uint32_t *) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 845 | ((uint8_t *) dev_priv->mmio->handle + SAVAGE_BCI_OFFSET); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 846 | if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) { |
| 847 | dev_priv->status_used_mask = SAVAGE_FIFO_USED_MASK_S3D; |
| 848 | } else { |
| 849 | dev_priv->status_used_mask = SAVAGE_FIFO_USED_MASK_S4; |
| 850 | } |
| 851 | if (dev_priv->status != NULL) { |
| 852 | dev_priv->status_ptr = |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 853 | (volatile uint32_t *)dev_priv->status->handle; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 854 | dev_priv->wait_fifo = savage_bci_wait_fifo_shadow; |
| 855 | dev_priv->wait_evnt = savage_bci_wait_event_shadow; |
| 856 | dev_priv->status_ptr[1023] = dev_priv->event_counter; |
| 857 | } else { |
| 858 | dev_priv->status_ptr = NULL; |
| 859 | if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) { |
| 860 | dev_priv->wait_fifo = savage_bci_wait_fifo_s3d; |
| 861 | } else { |
| 862 | dev_priv->wait_fifo = savage_bci_wait_fifo_s4; |
| 863 | } |
| 864 | dev_priv->wait_evnt = savage_bci_wait_event_reg; |
| 865 | } |
| 866 | |
| 867 | /* cliprect functions */ |
| 868 | if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) |
| 869 | dev_priv->emit_clip_rect = savage_emit_clip_rect_s3d; |
| 870 | else |
| 871 | dev_priv->emit_clip_rect = savage_emit_clip_rect_s4; |
| 872 | |
| 873 | if (savage_freelist_init(dev) < 0) { |
| 874 | DRM_ERROR("could not initialize freelist\n"); |
| 875 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 876 | return -ENOMEM; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 877 | } |
| 878 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 879 | if (savage_dma_init(dev_priv) < 0) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 880 | DRM_ERROR("could not initialize command DMA\n"); |
| 881 | savage_do_cleanup_bci(dev); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 882 | return -ENOMEM; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 883 | } |
| 884 | |
| 885 | return 0; |
| 886 | } |
| 887 | |
Dave Airlie | eddca55 | 2007-07-11 16:09:54 +1000 | [diff] [blame] | 888 | static int savage_do_cleanup_bci(struct drm_device * dev) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 889 | { |
| 890 | drm_savage_private_t *dev_priv = dev->dev_private; |
| 891 | |
| 892 | if (dev_priv->cmd_dma == &dev_priv->fake_dma) { |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 893 | kfree(dev_priv->fake_dma.handle); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 894 | } else if (dev_priv->cmd_dma && dev_priv->cmd_dma->handle && |
| 895 | dev_priv->cmd_dma->type == _DRM_AGP && |
| 896 | dev_priv->dma_type == SAVAGE_DMA_AGP) |
| 897 | drm_core_ioremapfree(dev_priv->cmd_dma, dev); |
| 898 | |
| 899 | if (dev_priv->dma_type == SAVAGE_DMA_AGP && |
| 900 | dev->agp_buffer_map && dev->agp_buffer_map->handle) { |
| 901 | drm_core_ioremapfree(dev->agp_buffer_map, dev); |
| 902 | /* make sure the next instance (which may be running |
| 903 | * in PCI mode) doesn't try to use an old |
| 904 | * agp_buffer_map. */ |
| 905 | dev->agp_buffer_map = NULL; |
| 906 | } |
| 907 | |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 908 | kfree(dev_priv->dma_pages); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 909 | |
| 910 | return 0; |
| 911 | } |
| 912 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 913 | static int savage_bci_init(struct drm_device *dev, void *data, struct drm_file *file_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 914 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 915 | drm_savage_init_t *init = data; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 916 | |
Eric Anholt | 6c340ea | 2007-08-25 20:23:09 +1000 | [diff] [blame] | 917 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 918 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 919 | switch (init->func) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 920 | case SAVAGE_INIT_BCI: |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 921 | return savage_do_init_bci(dev, init); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 922 | case SAVAGE_CLEANUP_BCI: |
| 923 | return savage_do_cleanup_bci(dev); |
| 924 | } |
| 925 | |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 926 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 927 | } |
| 928 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 929 | static int savage_bci_event_emit(struct drm_device *dev, void *data, struct drm_file *file_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 930 | { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 931 | drm_savage_private_t *dev_priv = dev->dev_private; |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 932 | drm_savage_event_emit_t *event = data; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 933 | |
| 934 | DRM_DEBUG("\n"); |
| 935 | |
Eric Anholt | 6c340ea | 2007-08-25 20:23:09 +1000 | [diff] [blame] | 936 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 937 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 938 | event->count = savage_bci_emit_event(dev_priv, event->flags); |
| 939 | event->count |= dev_priv->event_wrap << 16; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 940 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 941 | return 0; |
| 942 | } |
| 943 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 944 | static int savage_bci_event_wait(struct drm_device *dev, void *data, struct drm_file *file_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 945 | { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 946 | drm_savage_private_t *dev_priv = dev->dev_private; |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 947 | drm_savage_event_wait_t *event = data; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 948 | unsigned int event_e, hw_e; |
| 949 | unsigned int event_w, hw_w; |
| 950 | |
| 951 | DRM_DEBUG("\n"); |
| 952 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 953 | UPDATE_EVENT_COUNTER(); |
| 954 | if (dev_priv->status_ptr) |
| 955 | hw_e = dev_priv->status_ptr[1] & 0xffff; |
| 956 | else |
| 957 | hw_e = SAVAGE_READ(SAVAGE_STATUS_WORD1) & 0xffff; |
| 958 | hw_w = dev_priv->event_wrap; |
| 959 | if (hw_e > dev_priv->event_counter) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 960 | hw_w--; /* hardware hasn't passed the last wrap yet */ |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 961 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 962 | event_e = event->count & 0xffff; |
| 963 | event_w = event->count >> 16; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 964 | |
| 965 | /* Don't need to wait if |
| 966 | * - event counter wrapped since the event was emitted or |
| 967 | * - the hardware has advanced up to or over the event to wait for. |
| 968 | */ |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 969 | if (event_w < hw_w || (event_w == hw_w && event_e <= hw_e)) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 970 | return 0; |
| 971 | else |
| 972 | return dev_priv->wait_evnt(dev_priv, event_e); |
| 973 | } |
| 974 | |
| 975 | /* |
| 976 | * DMA buffer management |
| 977 | */ |
| 978 | |
Eric Anholt | 6c340ea | 2007-08-25 20:23:09 +1000 | [diff] [blame] | 979 | static int savage_bci_get_buffers(struct drm_device *dev, |
| 980 | struct drm_file *file_priv, |
| 981 | struct drm_dma *d) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 982 | { |
Dave Airlie | 056219e | 2007-07-11 16:17:42 +1000 | [diff] [blame] | 983 | struct drm_buf *buf; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 984 | int i; |
| 985 | |
| 986 | for (i = d->granted_count; i < d->request_count; i++) { |
| 987 | buf = savage_freelist_get(dev); |
| 988 | if (!buf) |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 989 | return -EAGAIN; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 990 | |
Eric Anholt | 6c340ea | 2007-08-25 20:23:09 +1000 | [diff] [blame] | 991 | buf->file_priv = file_priv; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 992 | |
Daniel Vetter | 1d6ac18 | 2013-12-11 11:34:44 +0100 | [diff] [blame] | 993 | if (copy_to_user(&d->request_indices[i], |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 994 | &buf->idx, sizeof(buf->idx))) |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 995 | return -EFAULT; |
Daniel Vetter | 1d6ac18 | 2013-12-11 11:34:44 +0100 | [diff] [blame] | 996 | if (copy_to_user(&d->request_sizes[i], |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 997 | &buf->total, sizeof(buf->total))) |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 998 | return -EFAULT; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 999 | |
| 1000 | d->granted_count++; |
| 1001 | } |
| 1002 | return 0; |
| 1003 | } |
| 1004 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1005 | int savage_bci_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv) |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1006 | { |
Dave Airlie | cdd55a2 | 2007-07-11 16:32:08 +1000 | [diff] [blame] | 1007 | struct drm_device_dma *dma = dev->dma; |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1008 | struct drm_dma *d = data; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1009 | int ret = 0; |
| 1010 | |
Eric Anholt | 6c340ea | 2007-08-25 20:23:09 +1000 | [diff] [blame] | 1011 | LOCK_TEST_WITH_RETURN(dev, file_priv); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1012 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1013 | /* Please don't send us buffers. |
| 1014 | */ |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1015 | if (d->send_count != 0) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1016 | DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n", |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1017 | DRM_CURRENTPID, d->send_count); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 1018 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1019 | } |
| 1020 | |
| 1021 | /* We'll send you buffers. |
| 1022 | */ |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1023 | if (d->request_count < 0 || d->request_count > dma->buf_count) { |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1024 | DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n", |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1025 | DRM_CURRENTPID, d->request_count, dma->buf_count); |
Eric Anholt | 20caafa | 2007-08-25 19:22:43 +1000 | [diff] [blame] | 1026 | return -EINVAL; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1027 | } |
| 1028 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1029 | d->granted_count = 0; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1030 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 1031 | if (d->request_count) { |
| 1032 | ret = savage_bci_get_buffers(dev, file_priv, d); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1033 | } |
| 1034 | |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1035 | return ret; |
| 1036 | } |
| 1037 | |
Eric Anholt | 6c340ea | 2007-08-25 20:23:09 +1000 | [diff] [blame] | 1038 | void savage_reclaim_buffers(struct drm_device *dev, struct drm_file *file_priv) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 1039 | { |
Dave Airlie | cdd55a2 | 2007-07-11 16:32:08 +1000 | [diff] [blame] | 1040 | struct drm_device_dma *dma = dev->dma; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1041 | drm_savage_private_t *dev_priv = dev->dev_private; |
Daniel Vetter | e2b3c5b | 2011-10-26 00:14:15 +0200 | [diff] [blame] | 1042 | int release_idlelock = 0; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1043 | int i; |
| 1044 | |
| 1045 | if (!dma) |
| 1046 | return; |
| 1047 | if (!dev_priv) |
| 1048 | return; |
| 1049 | if (!dma->buflist) |
| 1050 | return; |
| 1051 | |
Daniel Vetter | e2b3c5b | 2011-10-26 00:14:15 +0200 | [diff] [blame] | 1052 | if (file_priv->master && file_priv->master->lock.hw_lock) { |
| 1053 | drm_idlelock_take(&file_priv->master->lock); |
| 1054 | release_idlelock = 1; |
| 1055 | } |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1056 | |
| 1057 | for (i = 0; i < dma->buf_count; i++) { |
Dave Airlie | 056219e | 2007-07-11 16:17:42 +1000 | [diff] [blame] | 1058 | struct drm_buf *buf = dma->buflist[i]; |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1059 | drm_savage_buf_priv_t *buf_priv = buf->dev_private; |
| 1060 | |
Eric Anholt | 6c340ea | 2007-08-25 20:23:09 +1000 | [diff] [blame] | 1061 | if (buf->file_priv == file_priv && buf_priv && |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1062 | buf_priv->next == NULL && buf_priv->prev == NULL) { |
| 1063 | uint16_t event; |
| 1064 | DRM_DEBUG("reclaimed from client\n"); |
| 1065 | event = savage_bci_emit_event(dev_priv, SAVAGE_WAIT_3D); |
| 1066 | SET_AGE(&buf_priv->age, event, dev_priv->event_wrap); |
| 1067 | savage_freelist_put(dev, buf); |
| 1068 | } |
| 1069 | } |
| 1070 | |
Daniel Vetter | e2b3c5b | 2011-10-26 00:14:15 +0200 | [diff] [blame] | 1071 | if (release_idlelock) |
| 1072 | drm_idlelock_release(&file_priv->master->lock); |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1073 | } |
| 1074 | |
Rob Clark | baa7094 | 2013-08-02 13:27:49 -0400 | [diff] [blame] | 1075 | const struct drm_ioctl_desc savage_ioctls[] = { |
Dave Airlie | 1b2f148 | 2010-08-14 20:20:34 +1000 | [diff] [blame] | 1076 | DRM_IOCTL_DEF_DRV(SAVAGE_BCI_INIT, savage_bci_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), |
| 1077 | DRM_IOCTL_DEF_DRV(SAVAGE_BCI_CMDBUF, savage_bci_cmdbuf, DRM_AUTH), |
| 1078 | DRM_IOCTL_DEF_DRV(SAVAGE_BCI_EVENT_EMIT, savage_bci_event_emit, DRM_AUTH), |
| 1079 | DRM_IOCTL_DEF_DRV(SAVAGE_BCI_EVENT_WAIT, savage_bci_event_wait, DRM_AUTH), |
Dave Airlie | 282a167 | 2005-08-07 15:43:54 +1000 | [diff] [blame] | 1080 | }; |
| 1081 | |
| 1082 | int savage_max_ioctl = DRM_ARRAY_SIZE(savage_ioctls); |