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, ®off); 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 } 1011