pscnv/nouveau_bsddrv.c

   1 /*
   2  * Copyright 2005 Stephane Marchesin.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "nouveau_drv.h"
  26 #include "drm.h"
  27 #include "drm_crtc_helper.h"
  28 #include "nouveau_pm.h"
  29 #include "pscnv_gem.h"
  30 #include "pscnv_vm.h"
  31 #include "pscnv_chan.h"
  32 #if 0
  33 #include "nouveau_hw.h"
  34 #include "nouveau_fb.h"
  35 #include "nouveau_fbcon.h"
  36 #include "nv50_display.h"
  37 #endif
  38
  39 #include "drm_pciids.h"
  40 #include "pscnv_ioctl.h"
  41 #include "pscnv_kapi.h"
  42 #include "device_if.h"
  43
  44 #define MODULE_PARM_DESC(a, b)
  45 #define module_param_named(name, where, type, mode) TUNABLE_INT("drm.pscnv." #name, &where)
  46 #define module_param_str(name, where) TUNABLE_STR("drm.pscnv." #name , where, sizeof(where))
  47
  48 MODULE_PARM_DESC(agpmode, "AGP mode (0 to disable AGP)");
  49 int nouveau_agpmode = -1;
  50 module_param_named(agpmode, nouveau_agpmode, int, 0400);
  51
  52 MODULE_PARM_DESC(modeset, "Enable kernel modesetting");
  53 static int nouveau_modeset = 1; /* kms */
  54 module_param_named(modeset, nouveau_modeset, int, 0400);
  55
  56 MODULE_PARM_DESC(vbios, "Override default VBIOS location");
  57 char nouveau_vbios_array[32];
  58 char *nouveau_vbios = nouveau_vbios_array;
  59 module_param_str(vbios, nouveau_vbios_array);
  60
  61 MODULE_PARM_DESC(duallink, "Allow dual-link TMDS (>=GeForce 8)");
  62 int nouveau_duallink = 1;
  63 module_param_named(duallink, nouveau_duallink, int, 0400);
  64
  65 MODULE_PARM_DESC(uscript_lvds, "LVDS output script table ID (>=GeForce 8)");
  66 int nouveau_uscript_lvds = -1;
  67 module_param_named(uscript_lvds, nouveau_uscript_lvds, int, 0400);
  68
  69 MODULE_PARM_DESC(uscript_tmds, "TMDS output script table ID (>=GeForce 8)");
  70 int nouveau_uscript_tmds = -1;
  71 module_param_named(uscript_tmds, nouveau_uscript_tmds, int, 0400);
  72
  73 MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
  74 int nouveau_ignorelid = 0;
  75 module_param_named(ignorelid, nouveau_ignorelid, int, 0400);
  76
  77 MODULE_PARM_DESC(noaccel, "Disable all acceleration");
  78 int nouveau_noaccel = 0;
  79 module_param_named(noaccel, nouveau_noaccel, int, 0400);
  80
  81 MODULE_PARM_DESC(nofbaccel, "Disable fbcon acceleration");
  82 int nouveau_nofbaccel = 0;
  83 module_param_named(nofbaccel, nouveau_nofbaccel, int, 0400);
  84
  85 MODULE_PARM_DESC(force_post, "Force POST");
  86 int nouveau_force_post = 0;
  87 module_param_named(force_post, nouveau_force_post, int, 0400);
  88
  89 MODULE_PARM_DESC(override_conntype, "Ignore DCB connector type");
  90 int nouveau_override_conntype = 0;
  91 module_param_named(override_conntype, nouveau_override_conntype, int, 0400);
  92
  93 MODULE_PARM_DESC(tv_disable, "Disable TV-out detection\n");
  94 int nouveau_tv_disable = 0;
  95 module_param_named(tv_disable, nouveau_tv_disable, int, 0400);
  96
  97 MODULE_PARM_DESC(reg_debug, "Register access debug bitmask:\n"
  98                 "\t\t0x1 mc, 0x2 video, 0x4 fb, 0x8 extdev,\n"
  99                 "\t\t0x10 crtc, 0x20 ramdac, 0x40 vgacrtc, 0x80 rmvio,\n"
 100                 "\t\t0x100 vgaattr, 0x200 EVO (G80+). ");
 101 int nouveau_reg_debug;
 102 module_param_named(reg_debug, nouveau_reg_debug, int, 0600);
 103
 104 MODULE_PARM_DESC(perflvl, "Performance level (default: boot)\n");
 105 static char nouveau_perflvl_array[32];
 106 char *nouveau_perflvl = nouveau_perflvl_array;
 107 module_param_str(perflvl, nouveau_perflvl_array);
 108
 109 MODULE_PARM_DESC(perflvl_wr, "Allow perflvl changes (warning: dangerous!)\n");
 110 int nouveau_perflvl_wr;
 111 module_param_named(perflvl_wr, nouveau_perflvl_wr, int, 0400);
 112
 113 MODULE_PARM_DESC(mm_debug, "mm debug level: 0-2.");
 114 int pscnv_mm_debug = 0;
 115 module_param_named(mm_debug, pscnv_mm_debug, int, 0400);
 116
 117 MODULE_PARM_DESC(mem_debug, "memory debug level: 0-1.");
 118 int pscnv_mem_debug = 1;
 119 module_param_named(mem_debug, pscnv_mem_debug, int, 0400);
 120
 121 MODULE_PARM_DESC(vm_debug, "VM debug level: 0-2.");
 122 int pscnv_vm_debug = 1;
 123 module_param_named(vm_debug, pscnv_vm_debug, int, 0400);
 124
 125 MODULE_PARM_DESC(ramht_debug, "RAMHT debug level: 0-2.");
 126 int pscnv_ramht_debug = 0;
 127 module_param_named(ramht_debug, pscnv_ramht_debug, int, 0400);
 128
 129 MODULE_PARM_DESC(gem_debug, "GEM debug level: 0-1.");
 130 int pscnv_gem_debug = 1;
 131 module_param_named(gem_debug, pscnv_gem_debug, int, 0400);
 132
 133 int nouveau_fbpercrtc;
 134 #if 0
 135 module_param_named(fbpercrtc, nouveau_fbpercrtc, int, 0400);
 136 #endif
 137
 138 static drm_pci_id_list_t pciidlist[] = {
 139         {
 140                 /*PCI_VENDOR_ID_NVIDIA*/ 0x10de, 0U, 0, "nVidia graphics card"
 141         },
 142         {
 143                 /*PCI_VENDOR_ID_NVIDIA_SGS*/ 0x12d2, 0U, 0, "nVidia SGS graphics card"
 144         },
 145         {}
 146 };
 147
 148 static struct drm_driver_info driver;
 149
 150 static int
 151 pscnv_attach(device_t kdev)
 152 {
 153         struct drm_device *dev;
 154         dev = device_get_softc(kdev);
 155         if (nouveau_modeset == 1)
 156                 driver.driver_features |= DRIVER_MODESET;
 157         dev->driver = &driver;
 158         drm_sleep_locking_init(dev);
 159         return (drm_attach(kdev, pciidlist));
 160 }
 161
 162
 163 static int
 164 pscnv_probe(device_t kdev)
 165 {
 166         return drm_probe(kdev, pciidlist);
 167 }
 168
 169 static int
 170 nouveau_suspend(device_t kdev)
 171 {
 172         return (ENXIO);
 173 }
 174
 175 static int
 176 nouveau_resume(device_t kdev)
 177 {
 178         return (ENXIO);
 179 }
 180
 181 static device_method_t pscnv_methods[] = {
 182         /* Device interface */
 183         DEVMETHOD(device_probe,         pscnv_probe),
 184         DEVMETHOD(device_attach,        pscnv_attach),
 185 #ifdef DEVICE_AFTER_ATTACH
 186         DEVMETHOD(device_after_attach,  drm_after_attach),
 187 #endif
 188         DEVMETHOD(device_suspend,       nouveau_suspend),
 189         DEVMETHOD(device_resume,        nouveau_resume),
 190         DEVMETHOD(device_detach,        drm_detach),
 191         DEVMETHOD_END
 192 };
 193
 194 static driver_t pscnv_driver = {
 195         "drm",
 196         pscnv_methods,
 197         sizeof(struct drm_device)
 198 };
 199
 200 extern devclass_t drm_devclass;
 201 DRIVER_MODULE_ORDERED(pscnv, vgapci, pscnv_driver, drm_devclass, 0, 0,
 202     SI_ORDER_ANY);
 203 MODULE_DEPEND(pscnv, drm, 1, 1, 1);
 204 MODULE_DEPEND(pscnv, agp, 1, 1, 1);
 205 MODULE_DEPEND(pscnv, iicbus, 1, 1, 1);
 206 MODULE_DEPEND(pscnv, iic, 1, 1, 1);
 207 MODULE_DEPEND(pscnv, iicbb, 1, 1, 1);
 208
 209 struct drm_ioctl_desc nouveau_ioctls[] = {
 210         DRM_IOCTL_DEF(DRM_PSCNV_GETPARAM, pscnv_ioctl_getparam, DRM_UNLOCKED),
 211         DRM_IOCTL_DEF(DRM_PSCNV_GEM_NEW, pscnv_ioctl_gem_new, DRM_UNLOCKED),
 212         DRM_IOCTL_DEF(DRM_PSCNV_GEM_INFO, pscnv_ioctl_gem_info, DRM_UNLOCKED),
 213         DRM_IOCTL_DEF(DRM_PSCNV_VSPACE_NEW, pscnv_ioctl_vspace_new, DRM_UNLOCKED),
 214         DRM_IOCTL_DEF(DRM_PSCNV_VSPACE_FREE, pscnv_ioctl_vspace_free, DRM_UNLOCKED),
 215         DRM_IOCTL_DEF(DRM_PSCNV_VSPACE_MAP, pscnv_ioctl_vspace_map, DRM_UNLOCKED),
 216         DRM_IOCTL_DEF(DRM_PSCNV_VSPACE_UNMAP, pscnv_ioctl_vspace_unmap, DRM_UNLOCKED),
 217         DRM_IOCTL_DEF(DRM_PSCNV_CHAN_NEW, pscnv_ioctl_chan_new, DRM_UNLOCKED),
 218         DRM_IOCTL_DEF(DRM_PSCNV_CHAN_FREE, pscnv_ioctl_chan_free, DRM_UNLOCKED),
 219         DRM_IOCTL_DEF(DRM_PSCNV_OBJ_VDMA_NEW, pscnv_ioctl_obj_vdma_new, DRM_UNLOCKED),
 220         DRM_IOCTL_DEF(DRM_PSCNV_FIFO_INIT, pscnv_ioctl_fifo_init, DRM_UNLOCKED),
 221         DRM_IOCTL_DEF(DRM_PSCNV_OBJ_ENG_NEW, pscnv_ioctl_obj_eng_new, DRM_UNLOCKED),
 222         DRM_IOCTL_DEF(DRM_PSCNV_FIFO_INIT_IB, pscnv_ioctl_fifo_init_ib, DRM_UNLOCKED),
 223 };
 224
 225 static int
 226 pscnv_gem_pager_ctor(void *handle, vm_ooffset_t size, vm_prot_t prot,
 227     vm_ooffset_t foff, struct ucred *cred, u_short *color)
 228 {
 229         struct drm_gem_object *gem_obj = handle;
 230         struct drm_device *dev = gem_obj->dev;
 231         struct drm_nouveau_private *dev_priv = dev->dev_private;
 232         struct pscnv_bo *bo = gem_obj->driver_private;
 233         int ret;
 234         *color = 0; /* ...? */
 235
 236         if (!bo->fake_pages) {
 237                 bo->fake_pages = kzalloc(OFF_TO_IDX(bo->size) * sizeof(*bo->fake_pages), GFP_KERNEL);
 238                 if (!bo->fake_pages)
 239                         return (ENOMEM);
 240         }
 241
 242         if (!bo->chan && !bo->dmapages && (ret = -dev_priv->vm->map_user(bo)))
 243                 return (ret);
 244
 245         if (bo->chan)
 246                 pscnv_chan_ref(bo->chan);
 247         else
 248                 drm_gem_object_reference(gem_obj);
 249
 250         NV_WARN(dev, "Mapping %p\n", bo);
 251         return (0);
 252 }
 253
 254 static int
 255 pscnv_gem_pager_fault(vm_object_t vm_obj, vm_ooffset_t offset, int prot,
 256     vm_page_t *mres)
 257 {
 258         struct drm_gem_object *gem_obj = vm_obj->handle;
 259         struct pscnv_bo *bo = gem_obj->driver_private;
 260         struct drm_device *dev = gem_obj->dev;
 261         struct drm_nouveau_private *dev_priv = dev->dev_private;
 262         vm_page_t m = NULL;
 263         vm_memattr_t mattr;
 264         vm_paddr_t paddr;
 265         const char *what;
 266
 267         if (bo->chan) {
 268                 paddr = dev_priv->fb_phys + offset +
 269                         nvc0_fifo_ctrl_offs(dev, bo->chan->cid);
 270                 mattr = VM_MEMATTR_UNCACHEABLE;
 271                 what = "fifo";
 272         } else switch (bo->flags & PSCNV_GEM_MEMTYPE_MASK) {
 273         case PSCNV_GEM_VRAM_SMALL:
 274         case PSCNV_GEM_VRAM_LARGE:
 275                 paddr = dev_priv->fb_phys + bo->map1->start + offset;
 276                 mattr = VM_MEMATTR_WRITE_COMBINING;
 277                 what = "vram";
 278                 break;
 279         case PSCNV_GEM_SYSRAM_SNOOP:
 280         case PSCNV_GEM_SYSRAM_NOSNOOP:
 281                 paddr = bo->dmapages[OFF_TO_IDX(offset)];
 282                 mattr = VM_MEMATTR_WRITE_BACK;
 283                 what = "sysram";
 284                 break;
 285         default: return (EINVAL);
 286         }
 287
 288         if (offset >= bo->size) {
 289                 if (pscnv_mem_debug > 0)
 290                         NV_WARN(dev, "Reading %p + %08llx (%s) is past max size %08llx\n",
 291                                 bo, offset, what, bo->size);
 292                 return (VM_PAGER_ERROR);
 293         }
 294         if (pscnv_mem_debug > 0)
 295                 NV_WARN(dev, "Connecting %p+%08llx (%s) at phys %010llx\n",
 296                         bo, offset, what, paddr);
 297
 298         m = &bo->fake_pages[OFF_TO_IDX(offset)];
 299         /*
 300          * Replace the passed in reqpage page with our own fake page and
 301          * free up the all of the original pages.
 302          */
 303         if (*mres)
 304                 vm_page_putfake(*mres);
 305         *mres = m;
 306
 307         vm_page_initfake(m, paddr, mattr);
 308         pmap_page_init(m);
 309         m->oflags &= ~(VPO_BUSY | VPO_UNMANAGED);
 310         m->valid = VM_PAGE_BITS_ALL;
 311         vm_page_lock(m);
 312         vm_page_insert(m, vm_obj, OFF_TO_IDX(offset));
 313         vm_page_unlock(m);
 314         vm_page_busy(m);
 315         return (VM_PAGER_OK);
 316 }
 317
 318 static void
 319 pscnv_gem_pager_dtor(void *handle)
 320 {
 321         struct drm_gem_object *gem_obj = handle;
 322         struct pscnv_bo *bo = gem_obj->driver_private;
 323         struct drm_device *dev = gem_obj->dev;
 324         vm_object_t devobj = cdev_pager_lookup(handle);
 325
 326         if (devobj != NULL) {
 327                 vm_size_t page_count = OFF_TO_IDX(bo->size);
 328                 vm_page_t m;
 329                 int i;
 330                 VM_OBJECT_LOCK(devobj);
 331                 for (i = 0; i < page_count; i++) {
 332                         m = vm_page_lookup(devobj, i);
 333                         if (!m)
 334                                 continue;
 335                         if (pscnv_mem_debug > 0)
 336                                 NV_WARN(dev, "Freeing %010llx + %08llx (%p\n", bo->start, i * PAGE_SIZE, m);
 337                         cdev_pager_free_page(devobj, m);
 338                 }
 339                 VM_OBJECT_UNLOCK(devobj);
 340                 vm_object_deallocate(devobj);
 341         }
 342         else
 343                 NV_ERROR(dev, "Could not find handle %p\n", handle);
 344         if (pscnv_mem_debug > 0)
 345                 NV_WARN(dev, "Freed %010llx (%p)\n", bo->start, bo);
 346         kfree(bo->fake_pages);
 347
 348         if (bo->chan)
 349                 pscnv_chan_unref(bo->chan);
 350         else
 351                 drm_gem_object_unreference_unlocked(gem_obj);
 352 }
 353
 354 static struct cdev_pager_ops pscnv_gem_pager_ops = {
 355         .cdev_pg_fault  = pscnv_gem_pager_fault,
 356         .cdev_pg_ctor   = pscnv_gem_pager_ctor,
 357         .cdev_pg_dtor   = pscnv_gem_pager_dtor
 358 };
 359
 360 static struct drm_driver_info driver = {
 361         .driver_features =
 362                 DRIVER_USE_AGP | DRIVER_PCI_DMA | DRIVER_SG | DRIVER_USE_MTRR |
 363                 DRIVER_HAVE_IRQ | DRIVER_LOCKLESS_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM,
 364         .load = nouveau_load,
 365         .firstopen = nouveau_firstopen,
 366         .lastclose = nouveau_lastclose,
 367         .unload = nouveau_unload,
 368         .preclose = nouveau_preclose,
 369         .irq_preinstall = nouveau_irq_preinstall,
 370         .irq_postinstall = nouveau_irq_postinstall,
 371         .irq_uninstall = nouveau_irq_uninstall,
 372         .irq_handler = nouveau_irq_handler,
 373         .ioctls = nouveau_ioctls,
 374         .max_ioctl = DRM_ARRAY_SIZE(nouveau_ioctls),
 375
 376         // .gem_init_object ?
 377         // .dumb_* ?
 378         // sysctl init/cleanup ?
 379         .gem_free_object = pscnv_gem_free_object,
 380         .gem_pager_ops  = &pscnv_gem_pager_ops,
 381
 382         .name = DRIVER_NAME,
 383         .desc = DRIVER_DESC,
 384 #ifdef GIT_REVISION
 385         .date = GIT_REVISION,
 386 #else
 387         .date = DRIVER_DATE,
 388 #endif
 389         .major = DRIVER_MAJOR,
 390         .minor = DRIVER_MINOR,
 391         .patchlevel = DRIVER_PATCHLEVEL,
 392 };