usr/src/uts/common/io/drm/drm_drv.c

   1 /*
   2  * drm_drv.h -- Generic driver template -*- linux-c -*-
   3  * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
   4  */
   5 /*
   6  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
   7  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
   8  * Copyright (c) 2009, Intel Corporation.
   9  * All Rights Reserved.
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a
  12  * copy of this software and associated documentation files (the "Software"),
  13  * to deal in the Software without restriction, including without limitation
  14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  15  * and/or sell copies of the Software, and to permit persons to whom the
  16  * Software is furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice (including the next
  19  * paragraph) shall be included in all copies or substantial portions of the
  20  * Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  23  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  25  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  26  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  27  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  28  * OTHER DEALINGS IN THE SOFTWARE.
  29  *
  30  * Authors:
  31  *    Rickard E. (Rik) Faith <faith@valinux.com>
  32  *    Gareth Hughes <gareth@valinux.com>
  33  *
  34  */
  35
  36 /*
  37  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  38  * Use is subject to license terms.
  39  */
  40
  41 #include "drmP.h"
  42 #include "drm.h"
  43 #include "drm_sarea.h"
  44
  45 int drm_debug_flag = 1;
  46
  47 #define DRIVER_IOCTL_COUNT      256
  48 drm_ioctl_desc_t drm_ioctls[DRIVER_IOCTL_COUNT] = {
  49         [DRM_IOCTL_NR(DRM_IOCTL_VERSION)] =
  50             {drm_version, 0},
  51         [DRM_IOCTL_NR(DRM_IOCTL_GET_UNIQUE)] =
  52             {drm_getunique, 0},
  53         [DRM_IOCTL_NR(DRM_IOCTL_GET_MAGIC)] =
  54             {drm_getmagic, 0},
  55         [DRM_IOCTL_NR(DRM_IOCTL_IRQ_BUSID)] =
  56             {drm_irq_by_busid, DRM_MASTER|DRM_ROOT_ONLY},
  57         [DRM_IOCTL_NR(DRM_IOCTL_GET_MAP)] =
  58             {drm_getmap, 0},
  59         [DRM_IOCTL_NR(DRM_IOCTL_GET_CLIENT)] =
  60             {drm_getclient, 0},
  61         [DRM_IOCTL_NR(DRM_IOCTL_GET_STATS)] =
  62             {drm_getstats, 0},
  63         [DRM_IOCTL_NR(DRM_IOCTL_SET_VERSION)] =
  64             {drm_setversion, DRM_MASTER|DRM_ROOT_ONLY},
  65         [DRM_IOCTL_NR(DRM_IOCTL_MODESET_CTL)] =
  66             {drm_modeset_ctl, 0},
  67         [DRM_IOCTL_NR(DRM_IOCTL_GEM_CLOSE)] =
  68             {drm_gem_close_ioctl, 0},
  69         [DRM_IOCTL_NR(DRM_IOCTL_GEM_FLINK)] =
  70             {drm_gem_flink_ioctl, DRM_AUTH},
  71         [DRM_IOCTL_NR(DRM_IOCTL_GEM_OPEN)] =
  72             {drm_gem_open_ioctl, DRM_AUTH},
  73         [DRM_IOCTL_NR(DRM_IOCTL_SET_UNIQUE)] =
  74             {drm_setunique, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  75         [DRM_IOCTL_NR(DRM_IOCTL_BLOCK)] =
  76             {drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  77         [DRM_IOCTL_NR(DRM_IOCTL_UNBLOCK)] =
  78             {drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  79         [DRM_IOCTL_NR(DRM_IOCTL_AUTH_MAGIC)] =
  80             {drm_authmagic, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  81         [DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)] =
  82             {drm_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  83         [DRM_IOCTL_NR(DRM_IOCTL_RM_MAP)] =
  84             {drm_rmmap_ioctl, DRM_AUTH},
  85         [DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)] =
  86             {drm_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  87         [DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)] =
  88             {drm_getsareactx, DRM_AUTH},
  89         [DRM_IOCTL_NR(DRM_IOCTL_ADD_CTX)] =
  90             {drm_addctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  91         [DRM_IOCTL_NR(DRM_IOCTL_RM_CTX)] =
  92             {drm_rmctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  93         [DRM_IOCTL_NR(DRM_IOCTL_MOD_CTX)] =
  94             {drm_modctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  95         [DRM_IOCTL_NR(DRM_IOCTL_GET_CTX)] =
  96             {drm_getctx, DRM_AUTH},
  97         [DRM_IOCTL_NR(DRM_IOCTL_SWITCH_CTX)] =
  98             {drm_switchctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
  99         [DRM_IOCTL_NR(DRM_IOCTL_NEW_CTX)] =
 100             {drm_newctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 101         [DRM_IOCTL_NR(DRM_IOCTL_RES_CTX)] =
 102             {drm_resctx, DRM_AUTH},
 103         [DRM_IOCTL_NR(DRM_IOCTL_ADD_DRAW)] =
 104             {drm_adddraw, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 105         [DRM_IOCTL_NR(DRM_IOCTL_RM_DRAW)] =
 106             {drm_rmdraw, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 107         [DRM_IOCTL_NR(DRM_IOCTL_LOCK)] =
 108             {drm_lock, DRM_AUTH},
 109         [DRM_IOCTL_NR(DRM_IOCTL_UNLOCK)] =
 110             {drm_unlock, DRM_AUTH},
 111         [DRM_IOCTL_NR(DRM_IOCTL_FINISH)] =
 112             {drm_noop, DRM_AUTH},
 113         [DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)] =
 114             {drm_addbufs_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 115         [DRM_IOCTL_NR(DRM_IOCTL_MARK_BUFS)] =
 116             {drm_markbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 117         [DRM_IOCTL_NR(DRM_IOCTL_INFO_BUFS)] =
 118             {drm_infobufs, DRM_AUTH},
 119         [DRM_IOCTL_NR(DRM_IOCTL_MAP_BUFS)] =
 120             {drm_mapbufs, DRM_AUTH},
 121         [DRM_IOCTL_NR(DRM_IOCTL_FREE_BUFS)] =
 122             {drm_freebufs, DRM_AUTH},
 123         [DRM_IOCTL_NR(DRM_IOCTL_DMA)] =
 124             {drm_dma, DRM_AUTH},
 125         [DRM_IOCTL_NR(DRM_IOCTL_CONTROL)] =
 126             {drm_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 127         [DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)] =
 128             {drm_agp_acquire, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 129         [DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)] =
 130             {drm_agp_release, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 131         [DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)] =
 132             {drm_agp_enable, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 133         [DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)] =
 134             {drm_agp_info, DRM_AUTH},
 135         [DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC)] =
 136             {drm_agp_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 137         [DRM_IOCTL_NR(DRM_IOCTL_AGP_FREE)] =
 138             {drm_agp_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 139         [DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)] =
 140             {drm_agp_bind, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 141         [DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] =
 142             {drm_agp_unbind, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 143         [DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] =
 144             {drm_sg_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 145         [DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] =
 146             {drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 147         [DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] =
 148             {drm_wait_vblank, 0},
 149         [DRM_IOCTL_NR(DRM_IOCTL_UPDATE_DRAW)] =
 150             {drm_update_draw, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 151 };
 152
 153 extern void idr_list_free(struct idr_list *head);
 154
 155 const char *
 156 drm_find_description(int vendor, int device, drm_pci_id_list_t *idlist)
 157 {
 158         int i = 0;
 159         for (i = 0; idlist[i].vendor != 0; i++) {
 160         if ((idlist[i].vendor == vendor) &&
 161             (idlist[i].device == device)) {
 162                         return (idlist[i].name);
 163                 }
 164         }
 165         return (NULL);
 166 }
 167
 168 static int
 169 drm_firstopen(drm_device_t *dev)
 170 {
 171         int i;
 172         int retval;
 173         drm_local_map_t *map;
 174
 175         /* prebuild the SAREA */
 176         retval = drm_addmap(dev, 0, SAREA_MAX, _DRM_SHM,
 177             _DRM_CONTAINS_LOCK, &map);
 178         if (retval != 0) {
 179                 DRM_ERROR("firstopen: failed to prebuild SAREA");
 180                 return (retval);
 181         }
 182
 183         if (dev->driver->use_agp) {
 184                 DRM_DEBUG("drm_firstopen: use_agp=%d", dev->driver->use_agp);
 185                 if (drm_device_is_agp(dev))
 186                         dev->agp = drm_agp_init(dev);
 187                 if (dev->driver->require_agp && dev->agp == NULL) {
 188                         DRM_ERROR("couldn't initialize AGP");
 189                         return (EIO);
 190                 }
 191         }
 192
 193         if (dev->driver->firstopen)
 194                 retval = dev->driver->firstopen(dev);
 195
 196         if (retval != 0) {
 197                 DRM_ERROR("drm_firstopen: driver-specific firstopen failed");
 198                 return (retval);
 199         }
 200
 201         dev->buf_use = 0;
 202
 203         if (dev->driver->use_dma) {
 204                 i = drm_dma_setup(dev);
 205                 if (i != 0)
 206                         return (i);
 207         }
 208         dev->counters  = 6;
 209         dev->types[0]  = _DRM_STAT_LOCK;
 210         dev->types[1]  = _DRM_STAT_OPENS;
 211         dev->types[2]  = _DRM_STAT_CLOSES;
 212         dev->types[3]  = _DRM_STAT_IOCTLS;
 213         dev->types[4]  = _DRM_STAT_LOCKS;
 214         dev->types[5]  = _DRM_STAT_UNLOCKS;
 215
 216         for (i = 0; i < DRM_ARRAY_SIZE(dev->counts); i++)
 217                 *(&dev->counts[i]) = 0;
 218
 219         for (i = 0; i < DRM_HASH_SIZE; i++) {
 220                 dev->magiclist[i].head = NULL;
 221                 dev->magiclist[i].tail = NULL;
 222         }
 223
 224         dev->irq_enabled        = 0;
 225         dev->context_flag       = 0;
 226         dev->last_context       = 0;
 227         dev->if_version         = 0;
 228
 229         return (0);
 230 }
 231
 232 /* Free resources associated with the DRM on the last close. */
 233 static int
 234 drm_lastclose(drm_device_t *dev)
 235 {
 236         drm_magic_entry_t *pt, *next;
 237         drm_local_map_t *map, *mapsave;
 238         int i;
 239
 240         DRM_SPINLOCK_ASSERT(&dev->dev_lock);
 241
 242         if (dev->driver->lastclose != NULL)
 243                 dev->driver->lastclose(dev);
 244
 245         if (dev->irq_enabled)
 246                 (void) drm_irq_uninstall(dev);
 247
 248         if (dev->unique) {
 249                 drm_free(dev->unique, dev->unique_len + 1, DRM_MEM_DRIVER);
 250                 dev->unique = NULL;
 251                 dev->unique_len = 0;
 252         }
 253
 254         /* Clear pid list */
 255         for (i = 0; i < DRM_HASH_SIZE; i++) {
 256                 for (pt = dev->magiclist[i].head; pt; pt = next) {
 257                         next = pt->next;
 258                         drm_free(pt, sizeof (*pt), DRM_MEM_MAGIC);
 259                 }
 260                 dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
 261         }
 262
 263         /* Clear AGP information */
 264         if (dev->agp) {
 265                 drm_agp_mem_t *entry;
 266                 drm_agp_mem_t *nexte;
 267
 268                 /*
 269                  * Remove AGP resources, but leave dev->agp
 270                  * intact until drm_cleanup is called.
 271                  */
 272                 for (entry = dev->agp->memory; entry; entry = nexte) {
 273                         nexte = entry->next;
 274                         if (entry->bound)
 275                                 (void) drm_agp_unbind_memory(
 276                                     (unsigned long)entry->handle, dev);
 277                         (void) drm_agp_free_memory(entry->handle, dev);
 278                         drm_free(entry, sizeof (*entry), DRM_MEM_AGPLISTS);
 279                 }
 280                 dev->agp->memory = NULL;
 281
 282                 if (dev->agp->acquired)
 283                         (void) drm_agp_do_release(dev);
 284
 285                 dev->agp->acquired = 0;
 286                 dev->agp->enabled  = 0;
 287                 drm_agp_fini(dev);
 288         }
 289
 290         if (dev->sg != NULL) {
 291                 drm_sg_mem_t *entry;
 292                 entry = dev->sg;
 293                 dev->sg = NULL;
 294                 drm_sg_cleanup(dev, entry);
 295         }
 296
 297
 298         /* Clean up maps that weren't set up by the driver. */
 299         TAILQ_FOREACH_SAFE(map, &dev->maplist, link, mapsave) {
 300                 if (!map->kernel_owned)
 301                         drm_rmmap(dev, map);
 302         }
 303
 304         drm_dma_takedown(dev);
 305         if (dev->lock.hw_lock) {
 306                 dev->lock.hw_lock = NULL; /* SHM removed */
 307                 dev->lock.filp = NULL;
 308
 309                 mutex_enter(&(dev->lock.lock_mutex));
 310                 cv_broadcast(&(dev->lock.lock_cv));
 311                 mutex_exit(&(dev->lock.lock_mutex));
 312         }
 313
 314         return (0);
 315 }
 316
 317 static int
 318 drm_load(drm_device_t *dev)
 319 {
 320         int retcode;
 321
 322         cv_init(&(dev->lock.lock_cv), NULL, CV_DRIVER, NULL);
 323         mutex_init(&(dev->lock.lock_mutex), NULL, MUTEX_DRIVER, NULL);
 324         mutex_init(&(dev->dev_lock), "drmdev", MUTEX_DRIVER, NULL);
 325         mutex_init(&dev->irq_lock, "drmirq", MUTEX_DRIVER,
 326             (void *)dev->intr_block);
 327         mutex_init(&dev->drw_lock, "drmdrw", MUTEX_DRIVER, NULL);
 328         mutex_init(&dev->tasklet_lock, "drmtsk", MUTEX_DRIVER, NULL);
 329
 330         dev->irq = pci_get_irq(dev);
 331         dev->pci_vendor = pci_get_vendor(dev);
 332         dev->pci_device = pci_get_device(dev);
 333
 334         TAILQ_INIT(&dev->maplist);
 335         TAILQ_INIT(&dev->minordevs);
 336         TAILQ_INIT(&dev->files);
 337         if (dev->driver->load != NULL) {
 338                 retcode = dev->driver->load(dev, 0);
 339                 if (retcode != 0) {
 340                         DRM_ERROR("drm_load: failed\n");
 341                         goto error;
 342                 }
 343         }
 344
 345         retcode = drm_ctxbitmap_init(dev);
 346         if (retcode != 0) {
 347                 DRM_ERROR("drm_load: Cannot allocate memory for ctx bitmap");
 348                 goto error;
 349         }
 350
 351         if (dev->driver->use_gem == 1) {
 352                 retcode = drm_gem_init(dev);
 353                 if (retcode) {
 354                         DRM_ERROR("Cannot initialize graphics execution "
 355                             "manager (GEM)\n");
 356                         goto error;
 357                 }
 358         }
 359
 360         if (drm_init_kstats(dev)) {
 361                 DRM_ERROR("drm_attach => drm_load: init kstats error");
 362                 retcode = EFAULT;
 363                 goto error;
 364         }
 365
 366         DRM_INFO("!drm: Initialized %s %d.%d.%d %s ",
 367             dev->driver->driver_name,
 368             dev->driver->driver_major,
 369             dev->driver->driver_minor,
 370             dev->driver->driver_patchlevel,
 371             dev->driver->driver_date);
 372         return (0);
 373
 374 error:
 375         DRM_LOCK();
 376         (void) drm_lastclose(dev);
 377         DRM_UNLOCK();
 378         cv_destroy(&(dev->lock.lock_cv));
 379         mutex_destroy(&(dev->lock.lock_mutex));
 380         mutex_destroy(&dev->irq_lock);
 381         mutex_destroy(&(dev->dev_lock));
 382         mutex_destroy(&dev->drw_lock);
 383         mutex_destroy(&dev->tasklet_lock);
 384
 385         return (retcode);
 386 }
 387
 388 /* called when cleanup this module */
 389 static void
 390 drm_unload(drm_device_t *dev)
 391 {
 392         drm_local_map_t *map;
 393
 394         drm_vblank_cleanup(dev);
 395
 396         drm_ctxbitmap_cleanup(dev);
 397
 398         if (dev->driver->use_gem == 1) {
 399                 idr_list_free(&dev->object_name_idr);
 400                 mutex_destroy(&dev->object_name_lock);
 401         }
 402
 403         DRM_LOCK();
 404         (void) drm_lastclose(dev);
 405         DRM_UNLOCK();
 406
 407         while ((map = TAILQ_FIRST(&dev->maplist)) != NULL) {
 408                 drm_rmmap(dev, map);
 409         }
 410
 411         if (dev->driver->unload != NULL)
 412                 dev->driver->unload(dev);
 413
 414         drm_mem_uninit();
 415         cv_destroy(&dev->lock.lock_cv);
 416         mutex_destroy(&dev->lock.lock_mutex);
 417         mutex_destroy(&dev->irq_lock);
 418         mutex_destroy(&dev->dev_lock);
 419         mutex_destroy(&dev->drw_lock);
 420         mutex_destroy(&dev->tasklet_lock);
 421
 422         dev->gtt_total = 0;
 423         atomic_set(&dev->pin_memory, 0);
 424         DRM_ERROR("drm_unload");
 425 }
 426
 427
 428 /*ARGSUSED*/
 429 int
 430 drm_open(drm_device_t *dev, drm_cminor_t *mp, int openflags,
 431     int otyp, cred_t *credp)
 432 {
 433         int retcode;
 434
 435         retcode = drm_open_helper(dev, mp, openflags, otyp, credp);
 436
 437         if (!retcode) {
 438                 atomic_inc_32(&dev->counts[_DRM_STAT_OPENS]);
 439                 DRM_LOCK();
 440                 if (!dev->open_count ++)
 441                         retcode = drm_firstopen(dev);
 442                 DRM_UNLOCK();
 443         }
 444
 445         return (retcode);
 446 }
 447
 448 /*ARGSUSED*/
 449 int
 450 drm_close(drm_device_t *dev, int minor, int flag, int otyp,
 451     cred_t *credp)
 452 {
 453         drm_cminor_t    *mp;
 454         drm_file_t              *fpriv;
 455         int             retcode = 0;
 456
 457         DRM_LOCK();
 458         mp = drm_find_file_by_minor(dev, minor);
 459         if (!mp) {
 460                 DRM_UNLOCK();
 461                 DRM_ERROR("drm_close: can't find authenticator");
 462                 return (EACCES);
 463         }
 464
 465         fpriv = mp->fpriv;
 466         ASSERT(fpriv);
 467
 468         if (--fpriv->refs != 0)
 469                 goto done;
 470
 471         if (dev->driver->preclose != NULL)
 472                 dev->driver->preclose(dev, fpriv);
 473
 474         /*
 475          * Begin inline drm_release
 476          */
 477         DRM_DEBUG("drm_close :pid = %d , open_count = %d",
 478             DRM_CURRENTPID, dev->open_count);
 479
 480         if (dev->lock.hw_lock &&
 481             _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) &&
 482             dev->lock.filp == fpriv) {
 483                 DRM_DEBUG("Process %d dead, freeing lock for context %d",
 484                     DRM_CURRENTPID,
 485                     _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
 486                 if (dev->driver->reclaim_buffers_locked != NULL)
 487                         dev->driver->reclaim_buffers_locked(dev, fpriv);
 488                 (void) drm_lock_free(dev, &dev->lock.hw_lock->lock,
 489                     _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
 490         } else if (dev->driver->reclaim_buffers_locked != NULL &&
 491             dev->lock.hw_lock != NULL) {
 492                 DRM_ERROR("drm_close: "
 493                     "retake lock not implemented yet");
 494         }
 495
 496         if (dev->driver->use_dma) {
 497                 drm_reclaim_buffers(dev, fpriv);
 498         }
 499
 500         if (dev->driver->use_gem == 1) {
 501                 drm_gem_release(dev, fpriv);
 502         }
 503
 504         if (dev->driver->postclose != NULL) {
 505                 dev->driver->postclose(dev, fpriv);
 506         }
 507         TAILQ_REMOVE(&dev->files, fpriv, link);
 508         drm_free(fpriv, sizeof (*fpriv), DRM_MEM_FILES);
 509
 510 done:
 511         atomic_inc_32(&dev->counts[_DRM_STAT_CLOSES]);
 512
 513         TAILQ_REMOVE(&dev->minordevs, mp, link);
 514         drm_free(mp, sizeof (*mp), DRM_MEM_FILES);
 515
 516         if (--dev->open_count == 0) {
 517                 retcode = drm_lastclose(dev);
 518         }
 519         DRM_UNLOCK();
 520
 521         return (retcode);
 522 }
 523
 524 int
 525 drm_attach(drm_device_t *dev)
 526 {
 527         return (drm_load(dev));
 528 }
 529
 530 int
 531 drm_detach(drm_device_t *dev)
 532 {
 533         drm_unload(dev);
 534         drm_fini_kstats(dev);
 535         return (DDI_SUCCESS);
 536 }
 537
 538 static int
 539 drm_get_businfo(drm_device_t *dev)
 540 {
 541         dev->irq = pci_get_irq(dev);
 542         if (dev->irq == -1) {
 543                 DRM_ERROR("drm_get_businfo: get irq error");
 544                 return (DDI_FAILURE);
 545         }
 546         /* XXX Fix domain number (alpha hoses) */
 547         dev->pci_domain = 0;
 548         if (pci_get_info(dev, &dev->pci_bus,
 549             &dev->pci_slot, &dev->pci_func) != DDI_SUCCESS) {
 550                 DRM_ERROR("drm_get_businfo: get bus slot func error ");
 551                 return (DDI_FAILURE);
 552         }
 553         DRM_DEBUG("drm_get_businfo: pci bus: %d, pci slot :%d pci func %d",
 554             dev->pci_bus, dev->pci_slot, dev->pci_func);
 555         return (DDI_SUCCESS);
 556 }
 557
 558 int
 559 drm_probe(drm_device_t *dev, drm_pci_id_list_t *idlist)
 560 {
 561         const char *s = NULL;
 562         int vendor, device;
 563
 564         vendor = pci_get_vendor(dev);
 565         device = pci_get_device(dev);
 566
 567         s = drm_find_description(vendor, device, idlist);
 568         if (s != NULL) {
 569                 dev->desc = s;
 570                 if (drm_get_businfo(dev) != DDI_SUCCESS) {
 571                         DRM_ERROR("drm_probe: drm get bus info error");
 572                         return (DDI_FAILURE);
 573                 }
 574                 return (DDI_SUCCESS);
 575         }
 576         return (DDI_FAILURE);
 577 }