shared-core/radeon_ms_drm.c

   1 /*
   2  * Copyright 2007 Jérôme Glisse
   3  * Copyright 2007 Alex Deucher
   4  * Copyright 2007 Dave Airlie
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the next
  15  * paragraph) shall be included in all copies or substantial portions of the
  16  * Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  22  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24  * DEALINGS IN THE SOFTWARE.
  25  */
  26 /*
  27  * Authors:
  28  *    Jerome Glisse <glisse@freedesktop.org>
  29  */
  30 #include "drm_pciids.h"
  31 #include "radeon_ms.h"
  32 #include "amd_legacy_fence.h"
  33
  34
  35 static uint32_t radeon_ms_mem_prios[] = {
  36         DRM_BO_MEM_VRAM,
  37         DRM_BO_MEM_TT,
  38         DRM_BO_MEM_LOCAL,
  39 };
  40
  41 static uint32_t radeon_ms_busy_prios[] = {
  42         DRM_BO_MEM_TT,
  43         DRM_BO_MEM_VRAM,
  44         DRM_BO_MEM_LOCAL,
  45 };
  46
  47 struct drm_bo_driver radeon_ms_bo_driver = {
  48         .mem_type_prio = radeon_ms_mem_prios,
  49         .mem_busy_prio = radeon_ms_busy_prios,
  50         .num_mem_type_prio = sizeof(radeon_ms_mem_prios)/sizeof(uint32_t),
  51         .num_mem_busy_prio = sizeof(radeon_ms_busy_prios)/sizeof(uint32_t),
  52         .create_ttm_backend_entry = radeon_ms_create_ttm_backend,
  53         .fence_type = r3xx_fence_types,
  54         .invalidate_caches = radeon_ms_invalidate_caches,
  55         .init_mem_type = radeon_ms_init_mem_type,
  56         .evict_flags = radeon_ms_evict_flags,
  57         .move = radeon_ms_bo_move,
  58         .ttm_cache_flush = radeon_ms_ttm_flush,
  59 };
  60
  61 struct drm_ioctl_desc radeon_ms_ioctls[] = {
  62         DRM_IOCTL_DEF(DRM_RADEON_EXECBUFFER, radeon_ms_execbuffer, DRM_AUTH),
  63 };
  64 int radeon_ms_num_ioctls = DRM_ARRAY_SIZE(radeon_ms_ioctls);
  65
  66 int radeon_ms_driver_dma_ioctl(struct drm_device *dev, void *data,
  67                                struct drm_file *file_priv)
  68 {
  69         struct drm_device_dma *dma = dev->dma;
  70         struct drm_dma *d = data;
  71
  72         LOCK_TEST_WITH_RETURN(dev, file_priv);
  73
  74         /* Please don't send us buffers.
  75          */
  76         if (d->send_count != 0) {
  77                 DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n",
  78                           DRM_CURRENTPID, d->send_count);
  79                 return -EINVAL;
  80         }
  81
  82         /* Don't ask us buffer neither :)
  83          */
  84         DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
  85                   DRM_CURRENTPID, d->request_count, dma->buf_count);
  86         return -EINVAL;
  87 }
  88
  89 void radeon_ms_driver_lastclose(struct drm_device * dev)
  90 {
  91 }
  92
  93 int radeon_ms_driver_load(struct drm_device *dev, unsigned long flags)
  94 {
  95         struct drm_radeon_private *dev_priv;
  96         int ret = 0;
  97
  98         DRM_INFO("[radeon_ms] loading\n");
  99         /* allocate and clear device private structure */
 100         dev_priv = drm_alloc(sizeof(struct drm_radeon_private), DRM_MEM_DRIVER);
 101         if (dev_priv == NULL)
 102                 return -ENOMEM;
 103         memset(dev_priv, 0, sizeof(struct drm_radeon_private));
 104         dev->dev_private = (void *)dev_priv;
 105
 106         /* initialize modesetting structure (must be done here) */
 107         drm_mode_config_init(dev);
 108
 109         /* flags correspond to chipset family */
 110         dev_priv->usec_timeout = 100;
 111         dev_priv->family = flags & 0xffffU;
 112         dev_priv->bus_type = flags & 0xff0000U;
 113         /* initialize family functions */
 114         ret = radeon_ms_family_init(dev);
 115         if (ret != 0) {
 116                 radeon_ms_driver_unload(dev);
 117                 return ret;
 118         }
 119
 120         dev_priv->fence = drm_alloc(sizeof(struct legacy_fence), DRM_MEM_DRIVER);
 121         if (dev_priv->fence == NULL) {
 122                 radeon_ms_driver_unload(dev);
 123                 return -ENOMEM;
 124         }
 125         memset(dev_priv->fence, 0, sizeof(struct legacy_fence));
 126
 127         /* we don't want userspace to be able to map this so don't use
 128          * drm_addmap */
 129         dev_priv->mmio.offset = drm_get_resource_start(dev, 2);
 130         dev_priv->mmio.size = drm_get_resource_len(dev, 2);
 131         dev_priv->mmio.type = _DRM_REGISTERS;
 132         dev_priv->mmio.flags = _DRM_RESTRICTED;
 133         drm_core_ioremap(&dev_priv->mmio, dev);
 134         /* map vram FIXME: IGP likely don't have any of this */
 135         dev_priv->vram.offset = drm_get_resource_start(dev, 0);
 136         dev_priv->vram.size = drm_get_resource_len(dev, 0);
 137         dev_priv->vram.type = _DRM_FRAME_BUFFER;
 138         dev_priv->vram.flags = _DRM_RESTRICTED;
 139         drm_core_ioremap(&dev_priv->vram, dev);
 140
 141         /* save radeon initial state which will be restored upon module
 142          * exit */
 143         radeon_ms_state_save(dev, &dev_priv->load_state);
 144         dev_priv->restore_state = 1;
 145         memcpy(&dev_priv->driver_state, &dev_priv->load_state,
 146                sizeof(struct radeon_state));
 147
 148         /* initialize irq */
 149         ret = radeon_ms_irq_init(dev);
 150         if (ret != 0) {
 151                 radeon_ms_driver_unload(dev);
 152                 return ret;
 153         }
 154
 155         /* init bo driver */
 156         dev_priv->fence_id_last = 1;
 157         dev_priv->fence_reg = SCRATCH_REG2;
 158         ret = drm_bo_driver_init(dev);
 159         if (ret != 0) {
 160                 DRM_INFO("[radeon_ms] failed to init bo driver %d.\n", ret);
 161                 radeon_ms_driver_unload(dev);
 162                 return ret;
 163         }
 164         DRM_INFO("[radeon_ms] bo driver succesfull %d.\n", dev->bm.initialized);
 165         /* initialize vram */
 166         ret = drm_bo_init_mm(dev, DRM_BO_MEM_VRAM, 0, dev_priv->vram.size, 1);
 167         if (ret != 0) {
 168                 radeon_ms_driver_unload(dev);
 169                 return ret;
 170         }
 171
 172         /* initialize gpu address space (only after) VRAM initialization */
 173         ret = radeon_ms_gpu_initialize(dev);
 174         if (ret != 0) {
 175                 radeon_ms_driver_unload(dev);
 176                 return ret;
 177         }
 178         radeon_ms_gpu_restore(dev, &dev_priv->driver_state);
 179
 180         /* initialize ttm */
 181         ret = drm_bo_init_mm(dev, DRM_BO_MEM_TT, 0,
 182                              dev_priv->gpu_gart_size / RADEON_PAGE_SIZE, 1);
 183         if (ret != 0) {
 184                 radeon_ms_driver_unload(dev);
 185                 return ret;
 186         }
 187
 188         /* initialize ring buffer */
 189         /* set ring size to 4Mo FIXME: should make a parameter for this */
 190         dev_priv->write_back_area_size = 4 * 1024;
 191         dev_priv->ring_buffer_size = 4 * 1024 * 1024;
 192         ret = radeon_ms_cp_init(dev);
 193         if (ret != 0) {
 194                 radeon_ms_driver_unload(dev);
 195                 return ret;
 196         }
 197
 198         /* initialize modesetting */
 199         dev->mode_config.min_width = 0;
 200         dev->mode_config.min_height = 0;
 201         dev->mode_config.max_width = 4096;
 202         dev->mode_config.max_height = 4096;
 203         dev->mode_config.fb_base = dev_priv->vram.offset;
 204         ret = radeon_ms_crtc_create(dev, 1);
 205         if (ret != 0) {
 206                 radeon_ms_driver_unload(dev);
 207                 return ret;
 208         }
 209         ret = radeon_ms_outputs_from_rom(dev);
 210         if (ret < 0) {
 211                 radeon_ms_driver_unload(dev);
 212                 return ret;
 213         } else if (!ret) {
 214                 ret = radeon_ms_outputs_from_properties(dev);
 215                 if (ret < 0) {
 216                         radeon_ms_driver_unload(dev);
 217                         return ret;
 218                 } else if (ret == 0) {
 219                         DRM_INFO("[radeon_ms] no outputs !\n");
 220                 }
 221         } else {
 222                 DRM_INFO("[radeon_ms] added %d outputs from rom.\n", ret);
 223         }
 224         ret = radeon_ms_connectors_from_rom(dev);
 225         if (ret < 0) {
 226                 radeon_ms_driver_unload(dev);
 227                 return ret;
 228         } else if (!ret) {
 229                 ret = radeon_ms_connectors_from_properties(dev);
 230                 if (ret < 0) {
 231                         radeon_ms_driver_unload(dev);
 232                         return ret;
 233                 } else if (!ret) {
 234                         DRM_INFO("[radeon_ms] no connectors !\n");
 235                 }
 236         } else {
 237                 DRM_INFO("[radeon_ms] added %d connectors from rom.\n", ret);
 238         }
 239         radeon_ms_outputs_save(dev, &dev_priv->load_state);
 240         drm_initial_config(dev, false);
 241
 242         ret = drm_irq_install(dev);
 243         if (ret != 0) {
 244                 radeon_ms_driver_unload(dev);
 245                 return ret;
 246         }
 247
 248         if (dev->primary && dev->control) {
 249                 DRM_INFO("[radeon_ms] control 0x%lx, render 0x%lx\n",
 250                           (long)dev->primary->device, (long)dev->control->device);
 251         } else {
 252                 DRM_INFO("[radeon_ms] error control 0x%lx, render 0x%lx\n",
 253                           (long)dev->primary, (long)dev->control);
 254         }
 255         DRM_INFO("[radeon_ms] successfull initialization\n");
 256         return 0;
 257 }
 258
 259 int radeon_ms_driver_open(struct drm_device * dev, struct drm_file *file_priv)
 260 {
 261         return 0;
 262 }
 263
 264
 265 int radeon_ms_driver_unload(struct drm_device *dev)
 266 {
 267         struct drm_radeon_private *dev_priv = dev->dev_private;
 268
 269         if (dev_priv == NULL) {
 270                 return 0;
 271         }
 272
 273         /* cleanup modesetting */
 274         drm_mode_config_cleanup(dev);
 275         DRM_INFO("[radeon_ms] modesetting clean\n");
 276         radeon_ms_outputs_restore(dev, &dev_priv->load_state);
 277         radeon_ms_connectors_destroy(dev);
 278         radeon_ms_outputs_destroy(dev);
 279
 280         /* shutdown cp engine */
 281         radeon_ms_cp_finish(dev);
 282         DRM_INFO("[radeon_ms] cp clean\n");
 283
 284         drm_irq_uninstall(dev);
 285         DRM_INFO("[radeon_ms] irq uninstalled\n");
 286
 287         DRM_INFO("[radeon_ms] unloading\n");
 288         /* clean ttm memory manager */
 289         mutex_lock(&dev->struct_mutex);
 290         if (drm_bo_clean_mm(dev, DRM_BO_MEM_TT, 1)) {
 291                 DRM_ERROR("TT memory manager not clean. Delaying takedown\n");
 292         }
 293         mutex_unlock(&dev->struct_mutex);
 294         DRM_INFO("[radeon_ms] TT memory clean\n");
 295         /* finish */
 296         if (dev_priv->bus_finish) {
 297                 dev_priv->bus_finish(dev);
 298         }
 299         DRM_INFO("[radeon_ms] bus down\n");
 300         /* clean vram memory manager */
 301         mutex_lock(&dev->struct_mutex);
 302         if (drm_bo_clean_mm(dev, DRM_BO_MEM_VRAM, 1)) {
 303                 DRM_ERROR("VRAM memory manager not clean. Delaying takedown\n");
 304         }
 305         mutex_unlock(&dev->struct_mutex);
 306         DRM_INFO("[radeon_ms] VRAM memory clean\n");
 307         /* clean memory manager */
 308         drm_bo_driver_finish(dev);
 309         DRM_INFO("[radeon_ms] memory manager clean\n");
 310         /* restore card state */
 311         if (dev_priv->restore_state) {
 312                 radeon_ms_state_restore(dev, &dev_priv->load_state);
 313         }
 314         DRM_INFO("[radeon_ms] state restored\n");
 315         if (dev_priv->mmio.handle) {
 316                 drm_core_ioremapfree(&dev_priv->mmio, dev);
 317         }
 318         if (dev_priv->vram.handle) {
 319                 drm_core_ioremapfree(&dev_priv->vram, dev);
 320         }
 321         DRM_INFO("[radeon_ms] map released\n");
 322         drm_free(dev_priv->fence, sizeof(struct legacy_fence), DRM_MEM_DRIVER);
 323         drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
 324         dev->dev_private = NULL;
 325
 326
 327         DRM_INFO("[radeon_ms] that's all the folks\n");
 328         return 0;
 329 }
 330