1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 /*
  28  * Common misc module interfaces of DRM under Solaris
  29  */
  30 
  31 /*
  32  * This module calls into gfx and agpmaster misc modules respectively
  33  * for generic graphics operations and AGP master device support.
  34  */
  35 
  36 #include "drm_sunmod.h"
  37 #include <sys/modctl.h>
  38 #include <sys/kmem.h>
  39 #include <vm/seg_kmem.h>
  40 
  41 static struct modlmisc modlmisc = {
  42         &mod_miscops, "DRM common interfaces"
  43 };
  44 
  45 static struct modlinkage modlinkage = {
  46         MODREV_1, { (void *)&modlmisc, NULL }
  47 };
  48 
  49 static drm_inst_list_t  *drm_inst_head;
  50 static kmutex_t drm_inst_list_lock;
  51 
  52 static int drm_sun_open(dev_t *, int, int, cred_t *);
  53 static int drm_sun_close(dev_t, int, int, cred_t *);
  54 static int drm_sun_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
  55 static int drm_sun_devmap(dev_t, devmap_cookie_t, offset_t, size_t,
  56     size_t *, uint_t);
  57 
  58 /*
  59  * devmap callbacks for AGP and PCI GART
  60  */
  61 static int drm_devmap_map(devmap_cookie_t, dev_t,
  62     uint_t, offset_t, size_t, void **);
  63 static int drm_devmap_dup(devmap_cookie_t, void *,
  64     devmap_cookie_t, void **);
  65 static void drm_devmap_unmap(devmap_cookie_t, void *,
  66     offset_t, size_t, devmap_cookie_t, void **, devmap_cookie_t, void **);
  67 
  68 static drm_inst_list_t *drm_supp_alloc_drv_entry(dev_info_t *);
  69 static drm_inst_state_t *drm_sup_devt_to_state(dev_t);
  70 static void drm_supp_free_drv_entry(dev_info_t *);
  71 
  72 static struct devmap_callback_ctl drm_devmap_callbacks = {
  73                 DEVMAP_OPS_REV,                 /* devmap_rev */
  74                 drm_devmap_map,                         /* devmap_map */
  75                 NULL,                   /* devmap_access */
  76                 drm_devmap_dup,                 /* devmap_dup */
  77                 drm_devmap_unmap                /* devmap_unmap */
  78 };
  79 
  80 /*
  81  * Common device operations structure for all DRM drivers
  82  */
  83 struct cb_ops drm_cb_ops = {
  84         drm_sun_open,                   /* cb_open */
  85         drm_sun_close,                  /* cb_close */
  86         nodev,                                  /* cb_strategy */
  87         nodev,                                  /* cb_print */
  88         nodev,                                  /* cb_dump */
  89         nodev,                                  /* cb_read */
  90         nodev,                                  /* cb_write */
  91         drm_sun_ioctl,          /* cb_ioctl */
  92         drm_sun_devmap,         /* cb_devmap */
  93         nodev,                                  /* cb_mmap */
  94         NULL,                   /* cb_segmap */
  95         nochpoll,                               /* cb_chpoll */
  96         ddi_prop_op,            /* cb_prop_op */
  97         0,                                      /* cb_stream */
  98         D_NEW | D_MTSAFE |D_DEVMAP      /* cb_flag */
  99 };
 100 
 101 int
 102 _init(void)
 103 {
 104         int     error;
 105 
 106         if ((error = mod_install(&modlinkage)) != 0) {
 107                 return (error);
 108         }
 109 
 110         /* initialize the instance list lock */
 111         mutex_init(&drm_inst_list_lock, NULL, MUTEX_DRIVER, NULL);
 112         return (0);
 113 }
 114 
 115 int
 116 _fini(void)
 117 {
 118         int     err;
 119 
 120         if ((err = mod_remove(&modlinkage)) != 0)
 121                 return (err);
 122 
 123         mutex_destroy(&drm_inst_list_lock);
 124         return (0);
 125 }
 126 
 127 int
 128 _info(struct modinfo *modinfop)
 129 {
 130         return (mod_info(&modlinkage, modinfop));
 131 }
 132 
 133 void *
 134 drm_supp_register(dev_info_t *dip, drm_device_t *dp)
 135 {
 136         int             error;
 137         char    buf[80];
 138         int             instance = ddi_get_instance(dip);
 139         ddi_acc_handle_t        pci_cfg_handle;
 140         agp_master_softc_t      *agpm;
 141         drm_inst_state_t        *mstate;
 142         drm_inst_list_t         *entry;
 143         gfxp_vgatext_softc_ptr_t gfxp;
 144         struct dev_ops  *devop;
 145 
 146         ASSERT(dip != NULL);
 147 
 148         entry = drm_supp_alloc_drv_entry(dip);
 149         if (entry == NULL) {
 150                 cmn_err(CE_WARN, "drm_supp_register: failed to get softstate");
 151                 return (NULL);
 152         }
 153         mstate = &entry->disl_state;
 154 
 155         /*
 156          * DRM drivers are required to use common cb_ops
 157          */
 158         devop = ddi_get_driver(dip);
 159         if (devop->devo_cb_ops != &drm_cb_ops) {
 160                 devop->devo_cb_ops = &drm_cb_ops;
 161         }
 162 
 163         /* Generic graphics initialization */
 164         gfxp = gfxp_vgatext_softc_alloc();
 165         error = gfxp_vgatext_attach(dip, DDI_ATTACH, gfxp);
 166         if (error != DDI_SUCCESS) {
 167                 DRM_ERROR("drm_supp_regiter: failed to init gfx");
 168                 goto exit1;
 169         }
 170 
 171         /* create a minor node for common graphics ops */
 172         (void) sprintf(buf, "%s%d", GFX_NAME, instance);
 173         error = ddi_create_minor_node(dip, buf, S_IFCHR,
 174             INST2NODE0(instance), DDI_NT_DISPLAY, NULL);
 175         if (error != DDI_SUCCESS) {
 176                 DRM_ERROR("drm_supp_regiter: "
 177                     "failed to create minor node for gfx");
 178                 goto exit2;
 179         }
 180 
 181         /* setup mapping for later PCI config space access */
 182         error = pci_config_setup(dip, &pci_cfg_handle);
 183         if (error != DDI_SUCCESS) {
 184                 DRM_ERROR("drm_supp_regiter: "
 185                     "PCI configuration space setup failed");
 186                 goto exit2;
 187         }
 188 
 189         /* AGP master attach */
 190         agpm = NULL;
 191         if (dp->driver->use_agp) {
 192                 DRM_DEBUG("drm_supp_regiter: driver use AGP\n");
 193                 error = agpmaster_attach(dip, &agpm,
 194                     pci_cfg_handle, INST2NODE1(instance));
 195                 if ((error != DDI_SUCCESS) && (dp->driver->require_agp)) {
 196                         DRM_ERROR("drm_supp_regiter: "
 197                             "AGP master support not available");
 198                         goto exit3;
 199                 }
 200         }
 201 
 202         mutex_enter(&mstate->mis_lock);
 203         mstate->mis_major = ddi_driver_major(dip);
 204         mstate->mis_dip = dip;
 205         mstate->mis_gfxp = gfxp;
 206         mstate->mis_agpm = agpm;
 207         mstate->mis_cfg_hdl = pci_cfg_handle;
 208         mstate->mis_devp = dp;
 209         mutex_exit(&mstate->mis_lock);
 210 
 211         /* create minor node for DRM access */
 212         (void) sprintf(buf, "%s%d", DRM_DEVNODE, instance);
 213         if (ddi_create_minor_node(dip, buf, S_IFCHR,
 214             INST2NODE2(instance), DDI_NT_DISPLAY_DRM, 0)) {
 215                 DRM_ERROR("supp_regiter: faled to create minor node for drm");
 216                 goto exit4;
 217         }
 218 
 219         return ((void *)mstate);
 220 
 221 exit4:
 222         if ((dp->driver->use_agp) && agpm)
 223                 agpmaster_detach(&agpm);
 224 exit3:
 225         pci_config_teardown(&pci_cfg_handle);
 226 exit2:
 227         (void) gfxp_vgatext_detach(dip, DDI_DETACH, gfxp);
 228 exit1:
 229         gfxp_vgatext_softc_free(gfxp);
 230         drm_supp_free_drv_entry(dip);
 231         ddi_remove_minor_node(dip, NULL);
 232 
 233         return (NULL);
 234 }
 235 
 236 
 237 int
 238 drm_supp_unregister(void *handle)
 239 {
 240         drm_inst_list_t         *list;
 241         drm_inst_state_t        *mstate;
 242 
 243         list = (drm_inst_list_t *)handle;
 244         mstate = &list->disl_state;
 245         mutex_enter(&mstate->mis_lock);
 246 
 247         /* AGP master detach */
 248         if (mstate->mis_agpm != NULL)
 249                 agpmaster_detach(&mstate->mis_agpm);
 250 
 251         /* free PCI config access handle */
 252         if (mstate->mis_cfg_hdl)
 253                 pci_config_teardown(&mstate->mis_cfg_hdl);
 254 
 255         /* graphics misc module detach */
 256         if (mstate->mis_gfxp) {
 257                 (void) gfxp_vgatext_detach(mstate->mis_dip, DDI_DETACH,
 258                     mstate->mis_gfxp);
 259                 gfxp_vgatext_softc_free(mstate->mis_gfxp);
 260         }
 261 
 262         mstate->mis_devp = NULL;
 263 
 264         /* remove all minor nodes */
 265         ddi_remove_minor_node(mstate->mis_dip, NULL);
 266         mutex_exit(&mstate->mis_lock);
 267         drm_supp_free_drv_entry(mstate->mis_dip);
 268 
 269         return (DDI_SUCCESS);
 270 }
 271 
 272 
 273 /*ARGSUSED*/
 274 static int
 275 drm_sun_open(dev_t *devp, int flag, int otyp, cred_t *credp)
 276 {
 277         drm_inst_state_t        *mstate;
 278         drm_cminor_t    *mp, *newp;
 279         drm_device_t    *dp;
 280         minor_t         minor;
 281         int             newminor;
 282         int             instance;
 283         int             err;
 284 
 285         mstate = drm_sup_devt_to_state(*devp);
 286         /*
 287          * return ENXIO for deferred attach so that system can
 288          * attach us again.
 289          */
 290         if (mstate == NULL)
 291                 return (ENXIO);
 292 
 293         /*
 294          * The lest significant 15 bits are used for minor_number, and
 295          * the mid 3 bits are used for instance number. All minor numbers
 296          * are used as follows:
 297          * 0 -- gfx
 298          * 1 -- agpmaster
 299          * 2 -- drm
 300          * (3, MAX_CLONE_MINOR) -- drm minor node for clone open.
 301          */
 302         minor = DEV2MINOR(*devp);
 303         instance = DEV2INST(*devp);
 304         ASSERT(minor <= MAX_CLONE_MINOR);
 305 
 306         /*
 307          * No operations for VGA & AGP mater devices, always return OK.
 308          */
 309         if ((minor == GFX_MINOR) || (minor == AGPMASTER_MINOR))
 310                 return (0);
 311 
 312         /*
 313          * From here, we start to process drm
 314          */
 315 
 316         dp = mstate->mis_devp;
 317         if (!dp)
 318                 return (ENXIO);
 319 
 320         /*
 321          * Drm driver implements a software lock to serialize access
 322          * to graphics hardware based on per-process granulation. Before
 323          * operating graphics hardware, all clients, including kernel
 324          * and applications, must acquire this lock via DRM_IOCTL_LOCK
 325          * ioctl, and release it via DRM_IOCTL_UNLOCK after finishing
 326          * operations. Drm driver will grant r/w permission to the
 327          * process which acquires this lock (Kernel is assumed to have
 328          * process ID 0).
 329          *
 330          * A process might be terminated without releasing drm lock, in
 331          * this case, drm driver is responsible for clearing the holding.
 332          * To be informed of process exiting, drm driver uses clone open
 333          * to guarantee that each call to open(9e) have one corresponding
 334          * call to close(9e). In most cases, a process will close drm
 335          * during process termination, so that drm driver could have a
 336          * chance to release drm lock.
 337          *
 338          * In fact, a driver cannot know exactly when a process exits.
 339          * Clone open doesn't address this issue completely: Because of
 340          * inheritance, child processes inherit file descriptors from
 341          * their parent. As a result, if the parent exits before its
 342          * children, drm close(9e) entrypoint won't be called until all
 343          * of its children terminate.
 344          *
 345          * Another issue brought up by inhertance is the process PID
 346          * that calls the drm close() entry point may not be the same
 347          * as the one who called open(). Per-process struct is allocated
 348          * when a process first open() drm, and released when the process
 349          * last close() drm. Since open()/close() may be not the same
 350          * process, PID cannot be used for key to lookup per-process
 351          * struct. So, we associate minor number with per-process struct
 352          * during open()'ing, and find corresponding process struct
 353          * via minor number when close() is called.
 354          */
 355         newp = kmem_zalloc(sizeof (drm_cminor_t), KM_SLEEP);
 356         mutex_enter(&dp->dev_lock);
 357         for (newminor = DRM_MIN_CLONEMINOR; newminor < MAX_CLONE_MINOR;
 358             newminor ++) {
 359                 TAILQ_FOREACH(mp, &dp->minordevs, link) {
 360                         if (mp->minor == newminor)
 361                                 break;
 362                 }
 363                 if (mp == NULL)
 364                         goto gotminor;
 365         }
 366 
 367         mutex_exit(&dp->dev_lock);
 368         (void) kmem_free(newp, sizeof (drm_cminor_t));
 369         return (EMFILE);
 370 
 371 gotminor:
 372         TAILQ_INSERT_TAIL(&dp->minordevs, newp, link);
 373         newp->minor = newminor;
 374         mutex_exit(&dp->dev_lock);
 375         err = drm_open(dp, newp, flag, otyp, credp);
 376         if (err) {
 377                 mutex_enter(&dp->dev_lock);
 378                 TAILQ_REMOVE(&dp->minordevs, newp, link);
 379                 (void) kmem_free(newp, sizeof (drm_cminor_t));
 380                 mutex_exit(&dp->dev_lock);
 381 
 382                 return (err);
 383         }
 384 
 385         /* return a clone minor */
 386         newminor = newminor | (instance << NBITSMNODE);
 387         *devp = makedevice(getmajor(*devp), newminor);
 388         return (err);
 389 }
 390 
 391 /*ARGSUSED*/
 392 static int
 393 drm_sun_close(dev_t dev, int flag, int otyp, cred_t *credp)
 394 {
 395         drm_inst_state_t        *mstate;
 396         drm_device_t            *dp;
 397         minor_t         minor;
 398         int             ret;
 399 
 400         mstate = drm_sup_devt_to_state(dev);
 401         if (mstate == NULL)
 402                 return (EBADF);
 403 
 404         minor = DEV2MINOR(dev);
 405         ASSERT(minor <= MAX_CLONE_MINOR);
 406         if ((minor == GFX_MINOR) || (minor == AGPMASTER_MINOR))
 407                 return (0);
 408 
 409         dp = mstate->mis_devp;
 410         if (dp == NULL) {
 411                 DRM_ERROR("drm_sun_close: NULL soft state");
 412                 return (ENXIO);
 413         }
 414 
 415         ret = drm_close(dp, minor, flag, otyp, credp);
 416 
 417         return (ret);
 418 }
 419 
 420 /*ARGSUSED*/
 421 static int
 422 drm_sun_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
 423     cred_t *credp, int *rvalp)
 424 {
 425         extern drm_ioctl_desc_t drm_ioctls[];
 426 
 427         drm_inst_state_t        *mstate;
 428         drm_device_t            *dp;
 429         drm_ioctl_desc_t        *ioctl;
 430         drm_ioctl_t             *func;
 431         drm_file_t              *fpriv;
 432         minor_t         minor;
 433         int             retval;
 434         int             nr;
 435 
 436         if (cmd == VIS_GETIDENTIFIER) {
 437                 if (ddi_copyout(&text_ident, (void *)arg,
 438                     sizeof (struct vis_identifier), mode))
 439                         return (EFAULT);
 440         }
 441 
 442         mstate = drm_sup_devt_to_state(dev);
 443         if (mstate == NULL) {
 444                 return (EIO);
 445         }
 446 
 447         minor = DEV2MINOR(dev);
 448         ASSERT(minor <= MAX_CLONE_MINOR);
 449         switch (minor) {
 450         case GFX_MINOR:
 451                 retval = gfxp_vgatext_ioctl(dev, cmd, arg,
 452                     mode, credp, rvalp, mstate->mis_gfxp);
 453                 return (retval);
 454 
 455         case AGPMASTER_MINOR:
 456                 retval = agpmaster_ioctl(dev, cmd, arg, mode,
 457                     credp, rvalp, mstate->mis_agpm);
 458                 return (retval);
 459 
 460         case DRM_MINOR:
 461         default:        /* DRM cloning minor nodes */
 462                 break;
 463         }
 464 
 465         dp = mstate->mis_devp;
 466         ASSERT(dp != NULL);
 467 
 468         nr = DRM_IOCTL_NR(cmd);
 469         ioctl = &drm_ioctls[nr];
 470         atomic_inc_32(&dp->counts[_DRM_STAT_IOCTLS]);
 471 
 472         /* It's not a core DRM ioctl, try driver-specific. */
 473         if (ioctl->func == NULL && nr >= DRM_COMMAND_BASE) {
 474                 /* The array entries begin at DRM_COMMAND_BASE ioctl nr */
 475                 nr -= DRM_COMMAND_BASE;
 476                 if (nr > dp->driver->max_driver_ioctl) {
 477                         DRM_ERROR("Bad driver ioctl number, 0x%x (of 0x%x)",
 478                             nr, dp->driver->max_driver_ioctl);
 479                         return (EINVAL);
 480                 }
 481                 ioctl = &dp->driver->driver_ioctls[nr];
 482         }
 483 
 484         func = ioctl->func;
 485         if (func == NULL) {
 486                 return (ENOTSUP);
 487         }
 488 
 489         mutex_enter(&dp->dev_lock);
 490         fpriv = drm_find_file_by_proc(dp, credp);
 491         mutex_exit(&dp->dev_lock);
 492         if (fpriv == NULL) {
 493                 DRM_ERROR("drm_sun_ioctl : can't find authenticator");
 494                 return (EACCES);
 495         }
 496 
 497         if (((ioctl->flags & DRM_ROOT_ONLY) && !DRM_SUSER(credp)) ||
 498             ((ioctl->flags & DRM_AUTH) && !fpriv->authenticated) ||
 499             ((ioctl->flags & DRM_MASTER) && !fpriv->master))
 500                 return (EACCES);
 501 
 502         fpriv->dev = dev;
 503         fpriv->credp = credp;
 504 
 505         retval = func(dp, arg, fpriv, mode);
 506 
 507         return (retval);
 508 }
 509 
 510 /*ARGSUSED*/
 511 static int
 512 drm_sun_devmap(dev_t dev, devmap_cookie_t dhp, offset_t offset,
 513     size_t len, size_t *maplen, uint_t model)
 514 {
 515         extern int drm_get_pci_index_reg(dev_info_t *, uint_t, uint_t, off_t *);
 516 
 517         drm_inst_state_t        *mstate;
 518         drm_device_t            *dp;
 519         ddi_umem_cookie_t       cookie;
 520         drm_local_map_t         *map = NULL;
 521         unsigned long   aperbase;
 522         u_offset_t              handle;
 523         offset_t                koff;
 524         caddr_t                 kva;
 525         minor_t                 minor;
 526         size_t                  length;
 527         int                     ret;
 528 
 529         static ddi_device_acc_attr_t dev_attr = {
 530                 DDI_DEVICE_ATTR_V0,
 531                 DDI_NEVERSWAP_ACC,
 532                 DDI_STRICTORDER_ACC,
 533         };
 534         static ddi_device_acc_attr_t gem_dev_attr = {
 535                 DDI_DEVICE_ATTR_V0,
 536                 DDI_NEVERSWAP_ACC,
 537                 DDI_MERGING_OK_ACC
 538         };
 539 
 540         mstate = drm_sup_devt_to_state(dev);
 541         if (mstate == NULL)
 542                 return (ENXIO);
 543 
 544         minor = DEV2MINOR(dev);
 545         switch (minor) {
 546         case GFX_MINOR:
 547                 ret = gfxp_vgatext_devmap(dev, dhp, offset, len, maplen, model,
 548                     mstate->mis_gfxp);
 549                 return (ret);
 550 
 551         case AGPMASTER_MINOR:
 552                 return (ENOTSUP);
 553 
 554         case DRM_MINOR:
 555                 break;
 556 
 557         default:
 558                 /* DRM cloning nodes */
 559                 if (minor > MAX_CLONE_MINOR)
 560                         return (EBADF);
 561                 break;
 562         }
 563 
 564 
 565         dp = mstate->mis_devp;
 566         if (dp == NULL) {
 567                 DRM_ERROR("drm_sun_devmap: NULL soft state");
 568                 return (EINVAL);
 569         }
 570 
 571         mutex_enter(&dp->dev_lock);
 572 
 573         if (dp->driver->use_gem == 1) {
 574                 struct idr_list *entry;
 575                 drm_cminor_t *mp;
 576 
 577                 mp = drm_find_file_by_minor(dp, minor);
 578                 if (!mp) {
 579                         mutex_exit(&dp->dev_lock);
 580                         DRM_ERROR("drm_sun_devmap: can't find authenticator");
 581                         return (EACCES);
 582                 }
 583 
 584                 spin_lock(&dp->struct_mutex);
 585                 idr_list_for_each(entry, &(mp->fpriv->object_idr)) {
 586                         if ((uintptr_t)entry->obj == (u_offset_t)offset) {
 587                                 map = entry->obj->map;
 588                                 goto goon;
 589                         }
 590                 }
 591 goon:
 592                 spin_unlock(&dp->struct_mutex);
 593         }
 594 
 595         if (map == NULL) {
 596                 /*
 597                  * We will solve 32-bit application on 64-bit kernel
 598                  * issue later, now, we just use low 32-bit
 599                  */
 600                 handle = (u_offset_t)offset;
 601                 handle &= 0xffffffff;
 602 
 603                 TAILQ_FOREACH(map, &dp->maplist, link) {
 604                         if (handle ==
 605                             ((u_offset_t)((uintptr_t)map->handle) & 0xffffffff))
 606                                 break;
 607                 }
 608 
 609                 /*
 610                  * Temporarily, because offset is phys_addr for register
 611                  * and framebuffer, is kernel virtual_addr for others
 612                  * Maybe we will use hash table to solve this issue later.
 613                  */
 614                 if (map == NULL) {
 615                         TAILQ_FOREACH(map, &dp->maplist, link) {
 616                                 if (handle == (map->offset & 0xffffffff))
 617                                         break;
 618                         }
 619                 }
 620         }
 621 
 622         if (map == NULL) {
 623                 u_offset_t      tmp;
 624 
 625                 mutex_exit(&dp->dev_lock);
 626                 cmn_err(CE_WARN, "Can't find map, offset=0x%llx, len=%x\n",
 627                     offset, (int)len);
 628                 cmn_err(CE_WARN, "Current mapping:\n");
 629                 TAILQ_FOREACH(map, &dp->maplist, link) {
 630                 tmp = (u_offset_t)((uintptr_t)map->handle) & 0xffffffff;
 631                 cmn_err(CE_WARN, "map(handle=0x%p, size=0x%lx,type=%d,"
 632                     "offset=0x%lx), handle=%llx, tmp=%lld", map->handle,
 633                     map->size, map->type, map->offset, handle, tmp);
 634                 }
 635                 return (-1);
 636         }
 637         if (map->flags & _DRM_RESTRICTED) {
 638                 mutex_exit(&dp->dev_lock);
 639                 cmn_err(CE_WARN, "restricted map\n");
 640                 return (-1);
 641         }
 642 
 643         mutex_exit(&dp->dev_lock);
 644         switch (map->type) {
 645         case _DRM_FRAME_BUFFER:
 646         case _DRM_REGISTERS:
 647                 {
 648                         int     regno;
 649                         off_t   regoff;
 650 
 651                         regno = drm_get_pci_index_reg(dp->dip,
 652                             map->offset, (uint_t)len, &regoff);
 653                         if (regno < 0) {
 654                                 DRM_ERROR("devmap: failed to get register"
 655                                     " offset=0x%llx, len=0x%x", handle, len);
 656                                 return (EINVAL);
 657                         }
 658 
 659                         ret = devmap_devmem_setup(dhp, dp->dip, NULL,
 660                             regno, (offset_t)regoff, len, PROT_ALL,
 661                             0, &dev_attr);
 662                         if (ret != 0) {
 663                                 *maplen = 0;
 664                                 DRM_ERROR("devmap: failed, regno=%d,type=%d,"
 665                                     " handle=0x%x, offset=0x%llx, len=0x%x",
 666                                     regno, map->type, handle, offset, len);
 667                                 return (ret);
 668                         }
 669                         *maplen = len;
 670                         return (ret);
 671                 }
 672 
 673         case _DRM_SHM:
 674                 if (map->drm_umem_cookie == NULL)
 675                         return (EINVAL);
 676                 length = ptob(btopr(map->size));
 677                 ret = devmap_umem_setup(dhp, dp->dip, NULL,
 678                     map->drm_umem_cookie, 0, length,
 679                     PROT_ALL, IOMEM_DATA_CACHED, NULL);
 680                 if (ret != 0) {
 681                         *maplen = 0;
 682                         return (ret);
 683                 }
 684                 *maplen = length;
 685 
 686                 return (DDI_SUCCESS);
 687 
 688         case _DRM_AGP:
 689                 if (dp->agp == NULL) {
 690                         cmn_err(CE_WARN, "drm_sun_devmap: attempted to mmap AGP"
 691                             "memory before AGP support is enabled");
 692                         return (DDI_FAILURE);
 693                 }
 694 
 695                 aperbase = dp->agp->base;
 696                 koff = map->offset - aperbase;
 697                 length = ptob(btopr(len));
 698                 kva = map->dev_addr;
 699                 cookie = gfxp_umem_cookie_init(kva, length);
 700                 if (cookie == NULL) {
 701                         cmn_err(CE_WARN, "devmap:failed to get umem_cookie");
 702                         return (DDI_FAILURE);
 703                 }
 704 
 705                 if ((ret = devmap_umem_setup(dhp, dp->dip,
 706                     &drm_devmap_callbacks, cookie, 0, length, PROT_ALL,
 707                     IOMEM_DATA_UNCACHED | DEVMAP_ALLOW_REMAP, &dev_attr)) < 0) {
 708                         gfxp_umem_cookie_destroy(cookie);
 709                         cmn_err(CE_WARN, "devmap:failed, retval=%d", ret);
 710                         return (DDI_FAILURE);
 711                 }
 712                 *maplen = length;
 713                 break;
 714 
 715         case _DRM_SCATTER_GATHER:
 716                 koff = map->offset - (unsigned long)(caddr_t)dp->sg->virtual;
 717                 kva = map->dev_addr + koff;
 718                 length = ptob(btopr(len));
 719                 if (length > map->size) {
 720                         cmn_err(CE_WARN, "offset=0x%lx, virtual=0x%p,"
 721                             "mapsize=0x%lx,len=0x%lx", map->offset,
 722                             dp->sg->virtual, map->size, len);
 723                         return (DDI_FAILURE);
 724                 }
 725                 cookie = gfxp_umem_cookie_init(kva, length);
 726                 if (cookie == NULL) {
 727                         cmn_err(CE_WARN, "devmap:failed to get umem_cookie");
 728                         return (DDI_FAILURE);
 729                 }
 730                 ret = devmap_umem_setup(dhp, dp->dip,
 731                     &drm_devmap_callbacks, cookie, 0, length, PROT_ALL,
 732                     IOMEM_DATA_UNCACHED | DEVMAP_ALLOW_REMAP, &dev_attr);
 733                 if (ret != 0) {
 734                         cmn_err(CE_WARN, "sun_devmap: umem_setup fail");
 735                         gfxp_umem_cookie_destroy(cookie);
 736                         return (DDI_FAILURE);
 737                 }
 738                 *maplen = length;
 739                 break;
 740 
 741         case _DRM_TTM:
 742                 if (map->drm_umem_cookie == NULL)
 743                         return (EINVAL);
 744 
 745                 if (gfxp_devmap_umem_setup(dhp, dp->dip,
 746                     NULL, map->drm_umem_cookie, 0, map->size, PROT_ALL,
 747                     IOMEM_DATA_UC_WR_COMBINE | DEVMAP_ALLOW_REMAP,
 748                     &gem_dev_attr)) {
 749                         cmn_err(CE_WARN, "devmap:failed, retval=%d", ret);
 750                         return (DDI_FAILURE);
 751                 }
 752                 *maplen = map->size;
 753                 return (DDI_SUCCESS);
 754 
 755         default:
 756                 return (DDI_FAILURE);
 757         }
 758         return (DDI_SUCCESS);
 759 
 760 }
 761 
 762 /*ARGSUSED*/
 763 static int
 764 drm_devmap_map(devmap_cookie_t dhc, dev_t dev, uint_t flags,
 765     offset_t offset, size_t len, void **new_priv)
 766 {
 767         devmap_handle_t                 *dhp;
 768         drm_inst_state_t                *statep;
 769         struct ddi_umem_cookie  *cp;
 770 
 771         statep = drm_sup_devt_to_state(dev);
 772         ASSERT(statep != NULL);
 773 
 774         /*
 775          * This driver only supports MAP_SHARED,
 776          * and doesn't support MAP_PRIVATE
 777          */
 778         if (flags & MAP_PRIVATE) {
 779                 cmn_err(CE_WARN, "!DRM driver doesn't support MAP_PRIVATE");
 780                 return (EINVAL);
 781         }
 782 
 783         mutex_enter(&statep->dis_ctxlock);
 784         dhp = (devmap_handle_t *)dhc;
 785         cp = (struct ddi_umem_cookie *)dhp->dh_cookie;
 786         cp->cook_refcnt = 1;
 787         mutex_exit(&statep->dis_ctxlock);
 788         *new_priv = statep;
 789 
 790         return (0);
 791 }
 792 
 793 /*ARGSUSED*/
 794 static void
 795 drm_devmap_unmap(devmap_cookie_t dhc, void *pvtp, offset_t off, size_t len,
 796     devmap_cookie_t new_dhp1, void **new_pvtp1, devmap_cookie_t new_dhp2,
 797     void **new_pvtp2)
 798 {
 799         devmap_handle_t         *dhp;
 800         devmap_handle_t         *ndhp;
 801         drm_inst_state_t                *statep;
 802         struct ddi_umem_cookie  *cp;
 803         struct ddi_umem_cookie  *ncp;
 804 
 805         dhp = (devmap_handle_t *)dhc;
 806         statep = (drm_inst_state_t *)pvtp;
 807 
 808         mutex_enter(&statep->dis_ctxlock);
 809         cp = (struct ddi_umem_cookie *)dhp->dh_cookie;
 810         if (new_dhp1 != NULL) {
 811                 ndhp = (devmap_handle_t *)new_dhp1;
 812                 ncp = (struct ddi_umem_cookie *)ndhp->dh_cookie;
 813                 ncp->cook_refcnt ++;
 814                 *new_pvtp1 = statep;
 815                 ASSERT(ncp == cp);
 816         }
 817 
 818         if (new_dhp2 != NULL) {
 819                 ndhp = (devmap_handle_t *)new_dhp2;
 820                 ncp = (struct ddi_umem_cookie *)ndhp->dh_cookie;
 821                 ncp->cook_refcnt ++;
 822                 *new_pvtp2 = statep;
 823                 ASSERT(ncp == cp);
 824         }
 825 
 826         cp->cook_refcnt --;
 827         if (cp->cook_refcnt == 0) {
 828                 gfxp_umem_cookie_destroy(dhp->dh_cookie);
 829                 dhp->dh_cookie = NULL;
 830         }
 831         mutex_exit(&statep->dis_ctxlock);
 832 }
 833 
 834 
 835 /*ARGSUSED*/
 836 static int
 837 drm_devmap_dup(devmap_cookie_t dhc, void *pvtp, devmap_cookie_t new_dhc,
 838     void **new_pvtp)
 839 {
 840         devmap_handle_t                 *dhp;
 841         drm_inst_state_t    *statep;
 842         struct ddi_umem_cookie *cp;
 843 
 844         statep = (drm_inst_state_t *)pvtp;
 845         mutex_enter(&statep->dis_ctxlock);
 846         dhp = (devmap_handle_t *)dhc;
 847         cp = (struct ddi_umem_cookie *)dhp->dh_cookie;
 848         cp->cook_refcnt ++;
 849         mutex_exit(&statep->dis_ctxlock);
 850         *new_pvtp = statep;
 851 
 852         return (0);
 853 }
 854 
 855 int
 856 drm_dev_to_instance(dev_t dev)
 857 {
 858         return (DEV2INST(dev));
 859 }
 860 
 861 /*
 862  * drm_supp_alloc_drv_entry()
 863  *
 864  * Description:
 865  *      Create a DRM entry and add it into the instance list (drm_inst_head).
 866  *      Note that we don't allow a duplicated entry
 867  */
 868 static drm_inst_list_t *
 869 drm_supp_alloc_drv_entry(dev_info_t *dip)
 870 {
 871         drm_inst_list_t **plist;
 872         drm_inst_list_t *list;
 873         drm_inst_list_t *entry;
 874 
 875         /* protect the driver list */
 876         mutex_enter(&drm_inst_list_lock);
 877         plist = &drm_inst_head;
 878         list = *plist;
 879         while (list) {
 880                 if (list->disl_state.mis_dip == dip) {
 881                         mutex_exit(&drm_inst_list_lock);
 882                         cmn_err(CE_WARN, "%s%d already registered",
 883                             ddi_driver_name(dip), ddi_get_instance(dip));
 884                         return (NULL);
 885                 }
 886                 plist = &list->disl_next;
 887                 list = list->disl_next;
 888         }
 889 
 890         /* "dip" is not registered, create new one and add to list */
 891         entry = kmem_zalloc(sizeof (*entry), KM_SLEEP);
 892         *plist = entry;
 893         entry->disl_state.mis_dip = dip;
 894         mutex_init(&entry->disl_state.mis_lock, NULL, MUTEX_DRIVER, NULL);
 895         mutex_init(&entry->disl_state.dis_ctxlock, NULL, MUTEX_DRIVER, NULL);
 896         mutex_exit(&drm_inst_list_lock);
 897 
 898         return (entry);
 899 
 900 }       /* drm_supp_alloc_drv_entry */
 901 
 902 /*
 903  * drm_supp_free_drv_entry()
 904  */
 905 static void
 906 drm_supp_free_drv_entry(dev_info_t *dip)
 907 {
 908         drm_inst_list_t         *list;
 909         drm_inst_list_t         **plist;
 910         drm_inst_state_t        *mstate;
 911 
 912         /* protect the driver list */
 913         mutex_enter(&drm_inst_list_lock);
 914         plist = &drm_inst_head;
 915         list = *plist;
 916         while (list) {
 917                 if (list->disl_state.mis_dip == dip) {
 918                         *plist = list->disl_next;
 919                         mstate = &list->disl_state;
 920                         mutex_destroy(&mstate->mis_lock);
 921                         mutex_destroy(&mstate->dis_ctxlock);
 922                         kmem_free(list, sizeof (*list));
 923                         mutex_exit(&drm_inst_list_lock);
 924                         return;
 925                 }
 926                 plist = &list->disl_next;
 927                 list = list->disl_next;
 928         }
 929         mutex_exit(&drm_inst_list_lock);
 930 
 931 }       /* drm_supp_free_drv_entry() */
 932 
 933 /*
 934  * drm_sup_devt_to_state()
 935  *
 936  * description:
 937  *      Get the soft state of DRM instance by device number
 938  */
 939 static drm_inst_state_t *
 940 drm_sup_devt_to_state(dev_t dev)
 941 {
 942         drm_inst_list_t *list;
 943         drm_inst_state_t        *mstate;
 944         major_t major = getmajor(dev);
 945         int             instance = DEV2INST(dev);
 946 
 947         mutex_enter(&drm_inst_list_lock);
 948         list = drm_inst_head;
 949         while (list) {
 950                 mstate = &list->disl_state;
 951                 mutex_enter(&mstate->mis_lock);
 952 
 953                 if ((mstate->mis_major == major) &&
 954                     (ddi_get_instance(mstate->mis_dip) == instance)) {
 955                         mutex_exit(&mstate->mis_lock);
 956                         mutex_exit(&drm_inst_list_lock);
 957                         return (mstate);
 958                 }
 959 
 960                 list = list->disl_next;
 961                 mutex_exit(&mstate->mis_lock);
 962         }
 963 
 964         mutex_exit(&drm_inst_list_lock);
 965         return (NULL);
 966 
 967 }       /* drm_sup_devt_to_state() */
 968 
 969 int
 970 drm_supp_get_irq(void *handle)
 971 {
 972         drm_inst_list_t *list;
 973         drm_inst_state_t    *mstate;
 974         int             irq;
 975 
 976         list = (drm_inst_list_t *)handle;
 977         mstate = &list->disl_state;
 978         ASSERT(mstate != NULL);
 979         irq = pci_config_get8(mstate->mis_cfg_hdl, PCI_CONF_ILINE);
 980         return (irq);
 981 }
 982 
 983 int
 984 drm_supp_device_capability(void *handle, int capid)
 985 {
 986         drm_inst_list_t *list;
 987         drm_inst_state_t    *mstate;
 988         uint8_t         cap = 0;
 989         uint16_t        caps_ptr;
 990 
 991         list = (drm_inst_list_t *)handle;
 992         mstate = &list->disl_state;
 993         ASSERT(mstate != NULL);
 994 
 995         /* has capabilities list ? */
 996         if ((pci_config_get16(mstate->mis_cfg_hdl, PCI_CONF_STAT) &
 997             PCI_CONF_CAP_MASK) == 0)
 998                 return (NULL);
 999 
1000         caps_ptr = pci_config_get8(mstate->mis_cfg_hdl, PCI_CONF_CAP_PTR);
1001         while (caps_ptr != PCI_CAP_NEXT_PTR_NULL) {
1002                 cap = pci_config_get32(mstate->mis_cfg_hdl, caps_ptr);
1003                 if ((cap & PCI_CONF_CAPID_MASK) == capid)
1004                         return (cap);
1005                 caps_ptr = pci_config_get8(mstate->mis_cfg_hdl,
1006                     caps_ptr + PCI_CAP_NEXT_PTR);
1007         }
1008 
1009         return (0);
1010 }