1c0e09200SDave Airlie /* 2c0e09200SDave Airlie * Copyright 2003 José Fonseca. 3c0e09200SDave Airlie * Copyright 2003 Leif Delgass. 4c0e09200SDave Airlie * All Rights Reserved. 5c0e09200SDave Airlie * 6c0e09200SDave Airlie * Permission is hereby granted, free of charge, to any person obtaining a 7c0e09200SDave Airlie * copy of this software and associated documentation files (the "Software"), 8c0e09200SDave Airlie * to deal in the Software without restriction, including without limitation 9c0e09200SDave Airlie * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10c0e09200SDave Airlie * and/or sell copies of the Software, and to permit persons to whom the 11c0e09200SDave Airlie * Software is furnished to do so, subject to the following conditions: 12c0e09200SDave Airlie * 13c0e09200SDave Airlie * The above copyright notice and this permission notice (including the next 14c0e09200SDave Airlie * paragraph) shall be included in all copies or substantial portions of the 15c0e09200SDave Airlie * Software. 16c0e09200SDave Airlie * 17c0e09200SDave Airlie * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18c0e09200SDave Airlie * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19c0e09200SDave Airlie * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20c0e09200SDave Airlie * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 21c0e09200SDave Airlie * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 22c0e09200SDave Airlie * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23c0e09200SDave Airlie */ 24c0e09200SDave Airlie 25c0e09200SDave Airlie #include <linux/pci.h> 265a0e3ad6STejun Heo #include <linux/slab.h> 27c0e09200SDave Airlie #include <linux/dma-mapping.h> 282d1a8a48SPaul Gortmaker #include <linux/export.h> 29760285e7SDavid Howells #include <drm/drmP.h> 3043fc884eSVille Syrjälä #include "drm_internal.h" 31ba8286faSDaniel Vetter #include "drm_legacy.h" 32c0e09200SDave Airlie 33c0e09200SDave Airlie /** 34c6a1af8aSThierry Reding * drm_pci_alloc - Allocate a PCI consistent memory block, for DMA. 35c6a1af8aSThierry Reding * @dev: DRM device 36c6a1af8aSThierry Reding * @size: size of block to allocate 37c6a1af8aSThierry Reding * @align: alignment of block 38c6a1af8aSThierry Reding * 39c6a1af8aSThierry Reding * Return: A handle to the allocated memory block on success or NULL on 40c6a1af8aSThierry Reding * failure. 41c0e09200SDave Airlie */ 42e6be8d9dSZhenyu Wang drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align) 43c0e09200SDave Airlie { 44c0e09200SDave Airlie drm_dma_handle_t *dmah; 45c0e09200SDave Airlie unsigned long addr; 46c0e09200SDave Airlie size_t sz; 47c0e09200SDave Airlie 48c0e09200SDave Airlie /* pci_alloc_consistent only guarantees alignment to the smallest 49c0e09200SDave Airlie * PAGE_SIZE order which is greater than or equal to the requested size. 50c0e09200SDave Airlie * Return NULL here for now to make sure nobody tries for larger alignment 51c0e09200SDave Airlie */ 52c0e09200SDave Airlie if (align > size) 53c0e09200SDave Airlie return NULL; 54c0e09200SDave Airlie 55c0e09200SDave Airlie dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL); 56c0e09200SDave Airlie if (!dmah) 57c0e09200SDave Airlie return NULL; 58c0e09200SDave Airlie 59c0e09200SDave Airlie dmah->size = size; 60c0e09200SDave Airlie dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP); 61c0e09200SDave Airlie 62c0e09200SDave Airlie if (dmah->vaddr == NULL) { 63c0e09200SDave Airlie kfree(dmah); 64c0e09200SDave Airlie return NULL; 65c0e09200SDave Airlie } 66c0e09200SDave Airlie 67c0e09200SDave Airlie memset(dmah->vaddr, 0, size); 68c0e09200SDave Airlie 69c0e09200SDave Airlie /* XXX - Is virt_to_page() legal for consistent mem? */ 70c0e09200SDave Airlie /* Reserve */ 71c0e09200SDave Airlie for (addr = (unsigned long)dmah->vaddr, sz = size; 72c0e09200SDave Airlie sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { 73e1e78533SBen Hutchings SetPageReserved(virt_to_page((void *)addr)); 74c0e09200SDave Airlie } 75c0e09200SDave Airlie 76c0e09200SDave Airlie return dmah; 77c0e09200SDave Airlie } 78c0e09200SDave Airlie 79c0e09200SDave Airlie EXPORT_SYMBOL(drm_pci_alloc); 80c0e09200SDave Airlie 81c6a1af8aSThierry Reding /* 82c6a1af8aSThierry Reding * Free a PCI consistent memory block without freeing its descriptor. 83c0e09200SDave Airlie * 84c0e09200SDave Airlie * This function is for internal use in the Linux-specific DRM core code. 85c0e09200SDave Airlie */ 861c96e84eSDaniel Vetter void __drm_legacy_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) 87c0e09200SDave Airlie { 88c0e09200SDave Airlie unsigned long addr; 89c0e09200SDave Airlie size_t sz; 90c0e09200SDave Airlie 919a298b2aSEric Anholt if (dmah->vaddr) { 92c0e09200SDave Airlie /* XXX - Is virt_to_page() legal for consistent mem? */ 93c0e09200SDave Airlie /* Unreserve */ 94c0e09200SDave Airlie for (addr = (unsigned long)dmah->vaddr, sz = dmah->size; 95c0e09200SDave Airlie sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { 96e1e78533SBen Hutchings ClearPageReserved(virt_to_page((void *)addr)); 97c0e09200SDave Airlie } 98c0e09200SDave Airlie dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, 99c0e09200SDave Airlie dmah->busaddr); 100c0e09200SDave Airlie } 101c0e09200SDave Airlie } 102c0e09200SDave Airlie 103c0e09200SDave Airlie /** 104c6a1af8aSThierry Reding * drm_pci_free - Free a PCI consistent memory block 105c6a1af8aSThierry Reding * @dev: DRM device 106c6a1af8aSThierry Reding * @dmah: handle to memory block 107c0e09200SDave Airlie */ 108c0e09200SDave Airlie void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) 109c0e09200SDave Airlie { 1101c96e84eSDaniel Vetter __drm_legacy_pci_free(dev, dmah); 111c0e09200SDave Airlie kfree(dmah); 112c0e09200SDave Airlie } 113c0e09200SDave Airlie 114c0e09200SDave Airlie EXPORT_SYMBOL(drm_pci_free); 115c0e09200SDave Airlie 116dcdb1674SJordan Crouse #ifdef CONFIG_PCI 1178410ea3bSDave Airlie 1188410ea3bSDave Airlie static int drm_get_pci_domain(struct drm_device *dev) 1198410ea3bSDave Airlie { 1208410ea3bSDave Airlie #ifndef __alpha__ 1218410ea3bSDave Airlie /* For historical reasons, drm_get_pci_domain() is busticated 1228410ea3bSDave Airlie * on most archs and has to remain so for userspace interface 1238410ea3bSDave Airlie * < 1.4, except on alpha which was right from the beginning 1248410ea3bSDave Airlie */ 1258410ea3bSDave Airlie if (dev->if_version < 0x10004) 1268410ea3bSDave Airlie return 0; 1278410ea3bSDave Airlie #endif /* __alpha__ */ 1288410ea3bSDave Airlie 1298410ea3bSDave Airlie return pci_domain_nr(dev->pdev->bus); 1308410ea3bSDave Airlie } 1318410ea3bSDave Airlie 132915b4d11SDavid Herrmann int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) 1338410ea3bSDave Airlie { 134d0a39164SDavid Herrmann master->unique = kasprintf(GFP_KERNEL, "pci:%04x:%02x:%02x.%d", 1358410ea3bSDave Airlie drm_get_pci_domain(dev), 1368410ea3bSDave Airlie dev->pdev->bus->number, 1378410ea3bSDave Airlie PCI_SLOT(dev->pdev->devfn), 1388410ea3bSDave Airlie PCI_FUNC(dev->pdev->devfn)); 139d0a39164SDavid Herrmann if (!master->unique) 140d0a39164SDavid Herrmann return -ENOMEM; 1418410ea3bSDave Airlie 142d0a39164SDavid Herrmann master->unique_len = strlen(master->unique); 1438410ea3bSDave Airlie return 0; 1448410ea3bSDave Airlie } 145915b4d11SDavid Herrmann EXPORT_SYMBOL(drm_pci_set_busid); 1468410ea3bSDave Airlie 14753bf2a2bSDaniel Vetter int drm_pci_set_unique(struct drm_device *dev, 1488410ea3bSDave Airlie struct drm_master *master, 1498410ea3bSDave Airlie struct drm_unique *u) 1508410ea3bSDave Airlie { 1518410ea3bSDave Airlie int domain, bus, slot, func, ret; 1528410ea3bSDave Airlie 1538410ea3bSDave Airlie master->unique_len = u->unique_len; 1541e444be0SDavid Herrmann master->unique = kmalloc(master->unique_len + 1, GFP_KERNEL); 1558410ea3bSDave Airlie if (!master->unique) { 1568410ea3bSDave Airlie ret = -ENOMEM; 1578410ea3bSDave Airlie goto err; 1588410ea3bSDave Airlie } 1598410ea3bSDave Airlie 1608410ea3bSDave Airlie if (copy_from_user(master->unique, u->unique, master->unique_len)) { 1618410ea3bSDave Airlie ret = -EFAULT; 1628410ea3bSDave Airlie goto err; 1638410ea3bSDave Airlie } 1648410ea3bSDave Airlie 1658410ea3bSDave Airlie master->unique[master->unique_len] = '\0'; 1668410ea3bSDave Airlie 1678410ea3bSDave Airlie /* Return error if the busid submitted doesn't match the device's actual 1688410ea3bSDave Airlie * busid. 1698410ea3bSDave Airlie */ 1708410ea3bSDave Airlie ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func); 1718410ea3bSDave Airlie if (ret != 3) { 1728410ea3bSDave Airlie ret = -EINVAL; 1738410ea3bSDave Airlie goto err; 1748410ea3bSDave Airlie } 1758410ea3bSDave Airlie 1768410ea3bSDave Airlie domain = bus >> 8; 1778410ea3bSDave Airlie bus &= 0xff; 1788410ea3bSDave Airlie 1798410ea3bSDave Airlie if ((domain != drm_get_pci_domain(dev)) || 1808410ea3bSDave Airlie (bus != dev->pdev->bus->number) || 1818410ea3bSDave Airlie (slot != PCI_SLOT(dev->pdev->devfn)) || 1828410ea3bSDave Airlie (func != PCI_FUNC(dev->pdev->devfn))) { 1838410ea3bSDave Airlie ret = -EINVAL; 1848410ea3bSDave Airlie goto err; 1858410ea3bSDave Airlie } 1868410ea3bSDave Airlie return 0; 1878410ea3bSDave Airlie err: 1888410ea3bSDave Airlie return ret; 1898410ea3bSDave Airlie } 1908410ea3bSDave Airlie 19145e97ab6SWolfram Sang static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) 1928410ea3bSDave Airlie { 1938410ea3bSDave Airlie if ((p->busnum >> 8) != drm_get_pci_domain(dev) || 1948410ea3bSDave Airlie (p->busnum & 0xff) != dev->pdev->bus->number || 1958410ea3bSDave Airlie p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) 1968410ea3bSDave Airlie return -EINVAL; 1978410ea3bSDave Airlie 1988410ea3bSDave Airlie p->irq = dev->pdev->irq; 1998410ea3bSDave Airlie 2008410ea3bSDave Airlie DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, 2018410ea3bSDave Airlie p->irq); 2028410ea3bSDave Airlie return 0; 2038410ea3bSDave Airlie } 2048410ea3bSDave Airlie 205eaaf8f0fSDaniel Vetter /** 206c6a1af8aSThierry Reding * drm_irq_by_busid - Get interrupt from bus ID 207c6a1af8aSThierry Reding * @dev: DRM device 208c6a1af8aSThierry Reding * @data: IOCTL parameter pointing to a drm_irq_busid structure 209c6a1af8aSThierry Reding * @file_priv: DRM file private. 210eaaf8f0fSDaniel Vetter * 211eaaf8f0fSDaniel Vetter * Finds the PCI device with the specified bus id and gets its IRQ number. 212eaaf8f0fSDaniel Vetter * This IOCTL is deprecated, and will now return EINVAL for any busid not equal 213eaaf8f0fSDaniel Vetter * to that of the device that this DRM instance attached to. 214c6a1af8aSThierry Reding * 215c6a1af8aSThierry Reding * Return: 0 on success or a negative error code on failure. 216eaaf8f0fSDaniel Vetter */ 217eaaf8f0fSDaniel Vetter int drm_irq_by_busid(struct drm_device *dev, void *data, 218eaaf8f0fSDaniel Vetter struct drm_file *file_priv) 219eaaf8f0fSDaniel Vetter { 220eaaf8f0fSDaniel Vetter struct drm_irq_busid *p = data; 221eaaf8f0fSDaniel Vetter 222eaaf8f0fSDaniel Vetter if (drm_core_check_feature(dev, DRIVER_MODESET)) 223eaaf8f0fSDaniel Vetter return -EINVAL; 224eaaf8f0fSDaniel Vetter 225eaaf8f0fSDaniel Vetter /* UMS was only ever support on PCI devices. */ 226eaaf8f0fSDaniel Vetter if (WARN_ON(!dev->pdev)) 227eaaf8f0fSDaniel Vetter return -EINVAL; 228eaaf8f0fSDaniel Vetter 229eaaf8f0fSDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) 230eaaf8f0fSDaniel Vetter return -EINVAL; 231eaaf8f0fSDaniel Vetter 232eaaf8f0fSDaniel Vetter return drm_pci_irq_by_busid(dev, p); 233eaaf8f0fSDaniel Vetter } 234eaaf8f0fSDaniel Vetter 2358da79ccdSDaniel Vetter static void drm_pci_agp_init(struct drm_device *dev) 2368410ea3bSDave Airlie { 237d9906753SDaniel Vetter if (drm_core_check_feature(dev, DRIVER_USE_AGP)) { 2388410ea3bSDave Airlie if (drm_pci_device_is_agp(dev)) 2398410ea3bSDave Airlie dev->agp = drm_agp_init(dev); 24028185647SDaniel Vetter if (dev->agp) { 241f435046dSAndy Lutomirski dev->agp->agp_mtrr = arch_phys_wc_add( 242f435046dSAndy Lutomirski dev->agp->agp_info.aper_base, 2438410ea3bSDave Airlie dev->agp->agp_info.aper_size * 244f435046dSAndy Lutomirski 1024 * 1024); 2458410ea3bSDave Airlie } 2468410ea3bSDave Airlie } 2478410ea3bSDave Airlie } 2488410ea3bSDave Airlie 2494efafebeSDaniel Vetter void drm_pci_agp_destroy(struct drm_device *dev) 25028ec711cSDavid Herrmann { 251d9906753SDaniel Vetter if (dev->agp) { 25228ec711cSDavid Herrmann arch_phys_wc_del(dev->agp->agp_mtrr); 25328ec711cSDavid Herrmann drm_agp_clear(dev); 254d6e4b28bSDaniel Vetter kfree(dev->agp); 25528ec711cSDavid Herrmann dev->agp = NULL; 25628ec711cSDavid Herrmann } 25728ec711cSDavid Herrmann } 25828ec711cSDavid Herrmann 259dcdb1674SJordan Crouse /** 260c6a1af8aSThierry Reding * drm_get_pci_dev - Register a PCI device with the DRM subsystem 261c6a1af8aSThierry Reding * @pdev: PCI device 262c6a1af8aSThierry Reding * @ent: entry from the PCI ID table that matches @pdev 263c6a1af8aSThierry Reding * @driver: DRM device driver 264dcdb1674SJordan Crouse * 265dcdb1674SJordan Crouse * Attempt to gets inter module "drm" information. If we are first 266dcdb1674SJordan Crouse * then register the character device and inter module information. 267dcdb1674SJordan Crouse * Try and register, if we fail to register, backout previous work. 268c6a1af8aSThierry Reding * 2696e3f797cSDaniel Vetter * NOTE: This function is deprecated, please use drm_dev_alloc() and 2706e3f797cSDaniel Vetter * drm_dev_register() instead and remove your ->load() callback. 2716e3f797cSDaniel Vetter * 272c6a1af8aSThierry Reding * Return: 0 on success or a negative error code on failure. 273dcdb1674SJordan Crouse */ 274dcdb1674SJordan Crouse int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, 275dcdb1674SJordan Crouse struct drm_driver *driver) 276dcdb1674SJordan Crouse { 277dcdb1674SJordan Crouse struct drm_device *dev; 278dcdb1674SJordan Crouse int ret; 279dcdb1674SJordan Crouse 280dcdb1674SJordan Crouse DRM_DEBUG("\n"); 281dcdb1674SJordan Crouse 2821bb72532SDavid Herrmann dev = drm_dev_alloc(driver, &pdev->dev); 283dcdb1674SJordan Crouse if (!dev) 284dcdb1674SJordan Crouse return -ENOMEM; 285dcdb1674SJordan Crouse 286dcdb1674SJordan Crouse ret = pci_enable_device(pdev); 287dcdb1674SJordan Crouse if (ret) 288c22f0aceSDavid Herrmann goto err_free; 289dcdb1674SJordan Crouse 290dcdb1674SJordan Crouse dev->pdev = pdev; 291dcdb1674SJordan Crouse #ifdef __alpha__ 292dcdb1674SJordan Crouse dev->hose = pdev->sysdata; 293dcdb1674SJordan Crouse #endif 294dcdb1674SJordan Crouse 295c22f0aceSDavid Herrmann if (drm_core_check_feature(dev, DRIVER_MODESET)) 296dcdb1674SJordan Crouse pci_set_drvdata(pdev, dev); 297c22f0aceSDavid Herrmann 2982c695fa0SDaniel Vetter drm_pci_agp_init(dev); 2992c695fa0SDaniel Vetter 300c22f0aceSDavid Herrmann ret = drm_dev_register(dev, ent->driver_data); 301dcdb1674SJordan Crouse if (ret) 3022c695fa0SDaniel Vetter goto err_agp; 303dcdb1674SJordan Crouse 304dcdb1674SJordan Crouse DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 305dcdb1674SJordan Crouse driver->name, driver->major, driver->minor, driver->patchlevel, 306dcdb1674SJordan Crouse driver->date, pci_name(pdev), dev->primary->index); 307dcdb1674SJordan Crouse 308b3f2333dSDaniel Vetter /* No locking needed since shadow-attach is single-threaded since it may 309b3f2333dSDaniel Vetter * only be called from the per-driver module init hook. */ 310b3f2333dSDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 311b3f2333dSDaniel Vetter list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list); 312b3f2333dSDaniel Vetter 313dcdb1674SJordan Crouse return 0; 314dcdb1674SJordan Crouse 3152c695fa0SDaniel Vetter err_agp: 3162c695fa0SDaniel Vetter drm_pci_agp_destroy(dev); 317dcdb1674SJordan Crouse pci_disable_device(pdev); 318c22f0aceSDavid Herrmann err_free: 319099d1c29SDavid Herrmann drm_dev_unref(dev); 320dcdb1674SJordan Crouse return ret; 321dcdb1674SJordan Crouse } 322dcdb1674SJordan Crouse EXPORT_SYMBOL(drm_get_pci_dev); 323dcdb1674SJordan Crouse 324dcdb1674SJordan Crouse /** 325c6a1af8aSThierry Reding * drm_pci_init - Register matching PCI devices with the DRM subsystem 326c6a1af8aSThierry Reding * @driver: DRM device driver 327c6a1af8aSThierry Reding * @pdriver: PCI device driver 328dcdb1674SJordan Crouse * 329c6a1af8aSThierry Reding * Initializes a drm_device structures, registering the stubs and initializing 330c6a1af8aSThierry Reding * the AGP device. 331dcdb1674SJordan Crouse * 3326e3f797cSDaniel Vetter * NOTE: This function is deprecated. Modern modesetting drm drivers should use 3336e3f797cSDaniel Vetter * pci_register_driver() directly, this function only provides shadow-binding 3346e3f797cSDaniel Vetter * support for old legacy drivers on top of that core pci function. 3356e3f797cSDaniel Vetter * 336c6a1af8aSThierry Reding * Return: 0 on success or a negative error code on failure. 337dcdb1674SJordan Crouse */ 3388410ea3bSDave Airlie int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 339dcdb1674SJordan Crouse { 340dcdb1674SJordan Crouse struct pci_dev *pdev = NULL; 341dcdb1674SJordan Crouse const struct pci_device_id *pid; 342dcdb1674SJordan Crouse int i; 343dcdb1674SJordan Crouse 3448410ea3bSDave Airlie DRM_DEBUG("\n"); 3458410ea3bSDave Airlie 346dcdb1674SJordan Crouse if (driver->driver_features & DRIVER_MODESET) 3478410ea3bSDave Airlie return pci_register_driver(pdriver); 348dcdb1674SJordan Crouse 349dcdb1674SJordan Crouse /* If not using KMS, fall back to stealth mode manual scanning. */ 350b3f2333dSDaniel Vetter INIT_LIST_HEAD(&driver->legacy_dev_list); 3518410ea3bSDave Airlie for (i = 0; pdriver->id_table[i].vendor != 0; i++) { 3528410ea3bSDave Airlie pid = &pdriver->id_table[i]; 353dcdb1674SJordan Crouse 354dcdb1674SJordan Crouse /* Loop around setting up a DRM device for each PCI device 355dcdb1674SJordan Crouse * matching our ID and device class. If we had the internal 356dcdb1674SJordan Crouse * function that pci_get_subsys and pci_get_class used, we'd 357dcdb1674SJordan Crouse * be able to just pass pid in instead of doing a two-stage 358dcdb1674SJordan Crouse * thing. 359dcdb1674SJordan Crouse */ 360dcdb1674SJordan Crouse pdev = NULL; 361dcdb1674SJordan Crouse while ((pdev = 362dcdb1674SJordan Crouse pci_get_subsys(pid->vendor, pid->device, pid->subvendor, 363dcdb1674SJordan Crouse pid->subdevice, pdev)) != NULL) { 364dcdb1674SJordan Crouse if ((pdev->class & pid->class_mask) != pid->class) 365dcdb1674SJordan Crouse continue; 366dcdb1674SJordan Crouse 367dcdb1674SJordan Crouse /* stealth mode requires a manual probe */ 368dcdb1674SJordan Crouse pci_dev_get(pdev); 369dcdb1674SJordan Crouse drm_get_pci_dev(pdev, pid, driver); 370dcdb1674SJordan Crouse } 371dcdb1674SJordan Crouse } 372dcdb1674SJordan Crouse return 0; 373dcdb1674SJordan Crouse } 374dcdb1674SJordan Crouse 375f4297784SDave Airlie int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask) 376f4297784SDave Airlie { 377f4297784SDave Airlie struct pci_dev *root; 378dd66cc2eSBjorn Helgaas u32 lnkcap, lnkcap2; 379f4297784SDave Airlie 380f4297784SDave Airlie *mask = 0; 381f4297784SDave Airlie if (!dev->pdev) 382f4297784SDave Airlie return -EINVAL; 383f4297784SDave Airlie 384f4297784SDave Airlie root = dev->pdev->bus->self; 385f4297784SDave Airlie 386f4297784SDave Airlie /* we've been informed via and serverworks don't make the cut */ 387f4297784SDave Airlie if (root->vendor == PCI_VENDOR_ID_VIA || 388f4297784SDave Airlie root->vendor == PCI_VENDOR_ID_SERVERWORKS) 389f4297784SDave Airlie return -EINVAL; 390f4297784SDave Airlie 391dd66cc2eSBjorn Helgaas pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap); 392dd66cc2eSBjorn Helgaas pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2); 393f4297784SDave Airlie 394dd66cc2eSBjorn Helgaas if (lnkcap2) { /* PCIe r3.0-compliant */ 395f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB) 396f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_25; 397f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB) 398f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_50; 399f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB) 400f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_80; 401dd66cc2eSBjorn Helgaas } else { /* pre-r3.0 */ 4029fe0423eSBjorn Helgaas if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB) 403f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_25; 4049fe0423eSBjorn Helgaas if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB) 405f8acf6f4SBjorn Helgaas *mask |= (DRM_PCIE_SPEED_25 | DRM_PCIE_SPEED_50); 406f4297784SDave Airlie } 407f4297784SDave Airlie 408f4297784SDave Airlie DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2); 409f4297784SDave Airlie return 0; 410f4297784SDave Airlie } 411f4297784SDave Airlie EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask); 41293711d8bSBjorn Helgaas 41393711d8bSBjorn Helgaas #else 41493711d8bSBjorn Helgaas 41593711d8bSBjorn Helgaas int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 41693711d8bSBjorn Helgaas { 41793711d8bSBjorn Helgaas return -1; 41893711d8bSBjorn Helgaas } 41993711d8bSBjorn Helgaas 4204efafebeSDaniel Vetter void drm_pci_agp_destroy(struct drm_device *dev) {} 421eaaf8f0fSDaniel Vetter 422eaaf8f0fSDaniel Vetter int drm_irq_by_busid(struct drm_device *dev, void *data, 423eaaf8f0fSDaniel Vetter struct drm_file *file_priv) 424eaaf8f0fSDaniel Vetter { 425eaaf8f0fSDaniel Vetter return -EINVAL; 426eaaf8f0fSDaniel Vetter } 42753bf2a2bSDaniel Vetter 42853bf2a2bSDaniel Vetter int drm_pci_set_unique(struct drm_device *dev, 42953bf2a2bSDaniel Vetter struct drm_master *master, 43053bf2a2bSDaniel Vetter struct drm_unique *u) 43153bf2a2bSDaniel Vetter { 43253bf2a2bSDaniel Vetter return -EINVAL; 43353bf2a2bSDaniel Vetter } 43493711d8bSBjorn Helgaas #endif 43593711d8bSBjorn Helgaas 43693711d8bSBjorn Helgaas EXPORT_SYMBOL(drm_pci_init); 43793711d8bSBjorn Helgaas 438c6a1af8aSThierry Reding /** 439c6a1af8aSThierry Reding * drm_pci_exit - Unregister matching PCI devices from the DRM subsystem 440c6a1af8aSThierry Reding * @driver: DRM device driver 441c6a1af8aSThierry Reding * @pdriver: PCI device driver 442c6a1af8aSThierry Reding * 443c6a1af8aSThierry Reding * Unregisters one or more devices matched by a PCI driver from the DRM 444c6a1af8aSThierry Reding * subsystem. 4456e3f797cSDaniel Vetter * 4466e3f797cSDaniel Vetter * NOTE: This function is deprecated. Modern modesetting drm drivers should use 4476e3f797cSDaniel Vetter * pci_unregister_driver() directly, this function only provides shadow-binding 4486e3f797cSDaniel Vetter * support for old legacy drivers on top of that core pci function. 449c6a1af8aSThierry Reding */ 45093711d8bSBjorn Helgaas void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) 45193711d8bSBjorn Helgaas { 45293711d8bSBjorn Helgaas struct drm_device *dev, *tmp; 45393711d8bSBjorn Helgaas DRM_DEBUG("\n"); 45493711d8bSBjorn Helgaas 45593711d8bSBjorn Helgaas if (driver->driver_features & DRIVER_MODESET) { 45693711d8bSBjorn Helgaas pci_unregister_driver(pdriver); 45793711d8bSBjorn Helgaas } else { 458b3f2333dSDaniel Vetter list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list, 459b3f2333dSDaniel Vetter legacy_dev_list) { 460b3f2333dSDaniel Vetter list_del(&dev->legacy_dev_list); 461c94adc4aSDaniel Vetter drm_put_dev(dev); 462b3f2333dSDaniel Vetter } 46393711d8bSBjorn Helgaas } 46493711d8bSBjorn Helgaas DRM_INFO("Module unloaded\n"); 46593711d8bSBjorn Helgaas } 46693711d8bSBjorn Helgaas EXPORT_SYMBOL(drm_pci_exit); 467