1c0e09200SDave Airlie /* drm_pci.h -- PCI DMA memory management wrappers for DRM -*- linux-c -*- */ 2c0e09200SDave Airlie /** 3c0e09200SDave Airlie * \file drm_pci.c 4c0e09200SDave Airlie * \brief Functions and ioctls to manage PCI memory 5c0e09200SDave Airlie * 6c0e09200SDave Airlie * \warning These interfaces aren't stable yet. 7c0e09200SDave Airlie * 8c0e09200SDave Airlie * \todo Implement the remaining ioctl's for the PCI pools. 9c0e09200SDave Airlie * \todo The wrappers here are so thin that they would be better off inlined.. 10c0e09200SDave Airlie * 11c0e09200SDave Airlie * \author José Fonseca <jrfonseca@tungstengraphics.com> 12c0e09200SDave Airlie * \author Leif Delgass <ldelgass@retinalburn.net> 13c0e09200SDave Airlie */ 14c0e09200SDave Airlie 15c0e09200SDave Airlie /* 16c0e09200SDave Airlie * Copyright 2003 José Fonseca. 17c0e09200SDave Airlie * Copyright 2003 Leif Delgass. 18c0e09200SDave Airlie * All Rights Reserved. 19c0e09200SDave Airlie * 20c0e09200SDave Airlie * Permission is hereby granted, free of charge, to any person obtaining a 21c0e09200SDave Airlie * copy of this software and associated documentation files (the "Software"), 22c0e09200SDave Airlie * to deal in the Software without restriction, including without limitation 23c0e09200SDave Airlie * the rights to use, copy, modify, merge, publish, distribute, sublicense, 24c0e09200SDave Airlie * and/or sell copies of the Software, and to permit persons to whom the 25c0e09200SDave Airlie * Software is furnished to do so, subject to the following conditions: 26c0e09200SDave Airlie * 27c0e09200SDave Airlie * The above copyright notice and this permission notice (including the next 28c0e09200SDave Airlie * paragraph) shall be included in all copies or substantial portions of the 29c0e09200SDave Airlie * Software. 30c0e09200SDave Airlie * 31c0e09200SDave Airlie * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 32c0e09200SDave Airlie * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 33c0e09200SDave Airlie * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 34c0e09200SDave Airlie * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 35c0e09200SDave Airlie * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 36c0e09200SDave Airlie * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 37c0e09200SDave Airlie */ 38c0e09200SDave Airlie 39c0e09200SDave Airlie #include <linux/pci.h> 405a0e3ad6STejun Heo #include <linux/slab.h> 41c0e09200SDave Airlie #include <linux/dma-mapping.h> 422d1a8a48SPaul Gortmaker #include <linux/export.h> 43760285e7SDavid Howells #include <drm/drmP.h> 44c0e09200SDave Airlie 45c0e09200SDave Airlie /**********************************************************************/ 46c0e09200SDave Airlie /** \name PCI memory */ 47c0e09200SDave Airlie /*@{*/ 48c0e09200SDave Airlie 49c0e09200SDave Airlie /** 50c0e09200SDave Airlie * \brief Allocate a PCI consistent memory block, for DMA. 51c0e09200SDave Airlie */ 52e6be8d9dSZhenyu Wang drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align) 53c0e09200SDave Airlie { 54c0e09200SDave Airlie drm_dma_handle_t *dmah; 55c0e09200SDave Airlie unsigned long addr; 56c0e09200SDave Airlie size_t sz; 57c0e09200SDave Airlie 58c0e09200SDave Airlie /* pci_alloc_consistent only guarantees alignment to the smallest 59c0e09200SDave Airlie * PAGE_SIZE order which is greater than or equal to the requested size. 60c0e09200SDave Airlie * Return NULL here for now to make sure nobody tries for larger alignment 61c0e09200SDave Airlie */ 62c0e09200SDave Airlie if (align > size) 63c0e09200SDave Airlie return NULL; 64c0e09200SDave Airlie 65c0e09200SDave Airlie dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL); 66c0e09200SDave Airlie if (!dmah) 67c0e09200SDave Airlie return NULL; 68c0e09200SDave Airlie 69c0e09200SDave Airlie dmah->size = size; 70c0e09200SDave Airlie dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP); 71c0e09200SDave Airlie 72c0e09200SDave Airlie if (dmah->vaddr == NULL) { 73c0e09200SDave Airlie kfree(dmah); 74c0e09200SDave Airlie return NULL; 75c0e09200SDave Airlie } 76c0e09200SDave Airlie 77c0e09200SDave Airlie memset(dmah->vaddr, 0, size); 78c0e09200SDave Airlie 79c0e09200SDave Airlie /* XXX - Is virt_to_page() legal for consistent mem? */ 80c0e09200SDave Airlie /* Reserve */ 81c0e09200SDave Airlie for (addr = (unsigned long)dmah->vaddr, sz = size; 82c0e09200SDave Airlie sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { 83e1e78533SBen Hutchings SetPageReserved(virt_to_page((void *)addr)); 84c0e09200SDave Airlie } 85c0e09200SDave Airlie 86c0e09200SDave Airlie return dmah; 87c0e09200SDave Airlie } 88c0e09200SDave Airlie 89c0e09200SDave Airlie EXPORT_SYMBOL(drm_pci_alloc); 90c0e09200SDave Airlie 91c0e09200SDave Airlie /** 92c0e09200SDave Airlie * \brief Free a PCI consistent memory block without freeing its descriptor. 93c0e09200SDave Airlie * 94c0e09200SDave Airlie * This function is for internal use in the Linux-specific DRM core code. 95c0e09200SDave Airlie */ 96c0e09200SDave Airlie void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) 97c0e09200SDave Airlie { 98c0e09200SDave Airlie unsigned long addr; 99c0e09200SDave Airlie size_t sz; 100c0e09200SDave Airlie 1019a298b2aSEric Anholt if (dmah->vaddr) { 102c0e09200SDave Airlie /* XXX - Is virt_to_page() legal for consistent mem? */ 103c0e09200SDave Airlie /* Unreserve */ 104c0e09200SDave Airlie for (addr = (unsigned long)dmah->vaddr, sz = dmah->size; 105c0e09200SDave Airlie sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { 106e1e78533SBen Hutchings ClearPageReserved(virt_to_page((void *)addr)); 107c0e09200SDave Airlie } 108c0e09200SDave Airlie dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, 109c0e09200SDave Airlie dmah->busaddr); 110c0e09200SDave Airlie } 111c0e09200SDave Airlie } 112c0e09200SDave Airlie 113c0e09200SDave Airlie /** 114c0e09200SDave Airlie * \brief Free a PCI consistent memory block 115c0e09200SDave Airlie */ 116c0e09200SDave Airlie void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) 117c0e09200SDave Airlie { 118c0e09200SDave Airlie __drm_pci_free(dev, dmah); 119c0e09200SDave Airlie kfree(dmah); 120c0e09200SDave Airlie } 121c0e09200SDave Airlie 122c0e09200SDave Airlie EXPORT_SYMBOL(drm_pci_free); 123c0e09200SDave Airlie 124dcdb1674SJordan Crouse #ifdef CONFIG_PCI 1258410ea3bSDave Airlie 1268410ea3bSDave Airlie static int drm_get_pci_domain(struct drm_device *dev) 1278410ea3bSDave Airlie { 1288410ea3bSDave Airlie #ifndef __alpha__ 1298410ea3bSDave Airlie /* For historical reasons, drm_get_pci_domain() is busticated 1308410ea3bSDave Airlie * on most archs and has to remain so for userspace interface 1318410ea3bSDave Airlie * < 1.4, except on alpha which was right from the beginning 1328410ea3bSDave Airlie */ 1338410ea3bSDave Airlie if (dev->if_version < 0x10004) 1348410ea3bSDave Airlie return 0; 1358410ea3bSDave Airlie #endif /* __alpha__ */ 1368410ea3bSDave Airlie 1378410ea3bSDave Airlie return pci_domain_nr(dev->pdev->bus); 1388410ea3bSDave Airlie } 1398410ea3bSDave Airlie 1408410ea3bSDave Airlie static int drm_pci_get_irq(struct drm_device *dev) 1418410ea3bSDave Airlie { 1428410ea3bSDave Airlie return dev->pdev->irq; 1438410ea3bSDave Airlie } 1448410ea3bSDave Airlie 1458410ea3bSDave Airlie static const char *drm_pci_get_name(struct drm_device *dev) 1468410ea3bSDave Airlie { 1478410ea3bSDave Airlie struct pci_driver *pdriver = dev->driver->kdriver.pci; 1488410ea3bSDave Airlie return pdriver->name; 1498410ea3bSDave Airlie } 1508410ea3bSDave Airlie 151ea9cbb06SVille Syrjälä static int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) 1528410ea3bSDave Airlie { 1538410ea3bSDave Airlie int len, ret; 1548410ea3bSDave Airlie struct pci_driver *pdriver = dev->driver->kdriver.pci; 1558410ea3bSDave Airlie master->unique_len = 40; 1568410ea3bSDave Airlie master->unique_size = master->unique_len; 1578410ea3bSDave Airlie master->unique = kmalloc(master->unique_size, GFP_KERNEL); 1588410ea3bSDave Airlie if (master->unique == NULL) 1598410ea3bSDave Airlie return -ENOMEM; 1608410ea3bSDave Airlie 1618410ea3bSDave Airlie 1628410ea3bSDave Airlie len = snprintf(master->unique, master->unique_len, 1638410ea3bSDave Airlie "pci:%04x:%02x:%02x.%d", 1648410ea3bSDave Airlie drm_get_pci_domain(dev), 1658410ea3bSDave Airlie dev->pdev->bus->number, 1668410ea3bSDave Airlie PCI_SLOT(dev->pdev->devfn), 1678410ea3bSDave Airlie PCI_FUNC(dev->pdev->devfn)); 1688410ea3bSDave Airlie 1698410ea3bSDave Airlie if (len >= master->unique_len) { 1708410ea3bSDave Airlie DRM_ERROR("buffer overflow"); 1718410ea3bSDave Airlie ret = -EINVAL; 1728410ea3bSDave Airlie goto err; 1738410ea3bSDave Airlie } else 1748410ea3bSDave Airlie master->unique_len = len; 1758410ea3bSDave Airlie 1768410ea3bSDave Airlie dev->devname = 1778410ea3bSDave Airlie kmalloc(strlen(pdriver->name) + 1788410ea3bSDave Airlie master->unique_len + 2, GFP_KERNEL); 1798410ea3bSDave Airlie 1808410ea3bSDave Airlie if (dev->devname == NULL) { 1818410ea3bSDave Airlie ret = -ENOMEM; 1828410ea3bSDave Airlie goto err; 1838410ea3bSDave Airlie } 1848410ea3bSDave Airlie 1858410ea3bSDave Airlie sprintf(dev->devname, "%s@%s", pdriver->name, 1868410ea3bSDave Airlie master->unique); 1878410ea3bSDave Airlie 1888410ea3bSDave Airlie return 0; 1898410ea3bSDave Airlie err: 1908410ea3bSDave Airlie return ret; 1918410ea3bSDave Airlie } 1928410ea3bSDave Airlie 193ea9cbb06SVille Syrjälä static int drm_pci_set_unique(struct drm_device *dev, 1948410ea3bSDave Airlie struct drm_master *master, 1958410ea3bSDave Airlie struct drm_unique *u) 1968410ea3bSDave Airlie { 1978410ea3bSDave Airlie int domain, bus, slot, func, ret; 1988410ea3bSDave Airlie const char *bus_name; 1998410ea3bSDave Airlie 2008410ea3bSDave Airlie master->unique_len = u->unique_len; 2018410ea3bSDave Airlie master->unique_size = u->unique_len + 1; 2028410ea3bSDave Airlie master->unique = kmalloc(master->unique_size, GFP_KERNEL); 2038410ea3bSDave Airlie if (!master->unique) { 2048410ea3bSDave Airlie ret = -ENOMEM; 2058410ea3bSDave Airlie goto err; 2068410ea3bSDave Airlie } 2078410ea3bSDave Airlie 2088410ea3bSDave Airlie if (copy_from_user(master->unique, u->unique, master->unique_len)) { 2098410ea3bSDave Airlie ret = -EFAULT; 2108410ea3bSDave Airlie goto err; 2118410ea3bSDave Airlie } 2128410ea3bSDave Airlie 2138410ea3bSDave Airlie master->unique[master->unique_len] = '\0'; 2148410ea3bSDave Airlie 2158410ea3bSDave Airlie bus_name = dev->driver->bus->get_name(dev); 2168410ea3bSDave Airlie dev->devname = kmalloc(strlen(bus_name) + 2178410ea3bSDave Airlie strlen(master->unique) + 2, GFP_KERNEL); 2188410ea3bSDave Airlie if (!dev->devname) { 2198410ea3bSDave Airlie ret = -ENOMEM; 2208410ea3bSDave Airlie goto err; 2218410ea3bSDave Airlie } 2228410ea3bSDave Airlie 2238410ea3bSDave Airlie sprintf(dev->devname, "%s@%s", bus_name, 2248410ea3bSDave Airlie master->unique); 2258410ea3bSDave Airlie 2268410ea3bSDave Airlie /* Return error if the busid submitted doesn't match the device's actual 2278410ea3bSDave Airlie * busid. 2288410ea3bSDave Airlie */ 2298410ea3bSDave Airlie ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func); 2308410ea3bSDave Airlie if (ret != 3) { 2318410ea3bSDave Airlie ret = -EINVAL; 2328410ea3bSDave Airlie goto err; 2338410ea3bSDave Airlie } 2348410ea3bSDave Airlie 2358410ea3bSDave Airlie domain = bus >> 8; 2368410ea3bSDave Airlie bus &= 0xff; 2378410ea3bSDave Airlie 2388410ea3bSDave Airlie if ((domain != drm_get_pci_domain(dev)) || 2398410ea3bSDave Airlie (bus != dev->pdev->bus->number) || 2408410ea3bSDave Airlie (slot != PCI_SLOT(dev->pdev->devfn)) || 2418410ea3bSDave Airlie (func != PCI_FUNC(dev->pdev->devfn))) { 2428410ea3bSDave Airlie ret = -EINVAL; 2438410ea3bSDave Airlie goto err; 2448410ea3bSDave Airlie } 2458410ea3bSDave Airlie return 0; 2468410ea3bSDave Airlie err: 2478410ea3bSDave Airlie return ret; 2488410ea3bSDave Airlie } 2498410ea3bSDave Airlie 25045e97ab6SWolfram Sang static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) 2518410ea3bSDave Airlie { 2528410ea3bSDave Airlie if ((p->busnum >> 8) != drm_get_pci_domain(dev) || 2538410ea3bSDave Airlie (p->busnum & 0xff) != dev->pdev->bus->number || 2548410ea3bSDave Airlie p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) 2558410ea3bSDave Airlie return -EINVAL; 2568410ea3bSDave Airlie 2578410ea3bSDave Airlie p->irq = dev->pdev->irq; 2588410ea3bSDave Airlie 2598410ea3bSDave Airlie DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, 2608410ea3bSDave Airlie p->irq); 2618410ea3bSDave Airlie return 0; 2628410ea3bSDave Airlie } 2638410ea3bSDave Airlie 264eaaf8f0fSDaniel Vetter /** 265eaaf8f0fSDaniel Vetter * Get interrupt from bus id. 266eaaf8f0fSDaniel Vetter * 267eaaf8f0fSDaniel Vetter * \param inode device inode. 268eaaf8f0fSDaniel Vetter * \param file_priv DRM file private. 269eaaf8f0fSDaniel Vetter * \param cmd command. 270eaaf8f0fSDaniel Vetter * \param arg user argument, pointing to a drm_irq_busid structure. 271eaaf8f0fSDaniel Vetter * \return zero on success or a negative number on failure. 272eaaf8f0fSDaniel Vetter * 273eaaf8f0fSDaniel Vetter * Finds the PCI device with the specified bus id and gets its IRQ number. 274eaaf8f0fSDaniel Vetter * This IOCTL is deprecated, and will now return EINVAL for any busid not equal 275eaaf8f0fSDaniel Vetter * to that of the device that this DRM instance attached to. 276eaaf8f0fSDaniel Vetter */ 277eaaf8f0fSDaniel Vetter int drm_irq_by_busid(struct drm_device *dev, void *data, 278eaaf8f0fSDaniel Vetter struct drm_file *file_priv) 279eaaf8f0fSDaniel Vetter { 280eaaf8f0fSDaniel Vetter struct drm_irq_busid *p = data; 281eaaf8f0fSDaniel Vetter 282eaaf8f0fSDaniel Vetter if (drm_core_check_feature(dev, DRIVER_MODESET)) 283eaaf8f0fSDaniel Vetter return -EINVAL; 284eaaf8f0fSDaniel Vetter 285eaaf8f0fSDaniel Vetter /* UMS was only ever support on PCI devices. */ 286eaaf8f0fSDaniel Vetter if (WARN_ON(!dev->pdev)) 287eaaf8f0fSDaniel Vetter return -EINVAL; 288eaaf8f0fSDaniel Vetter 289eaaf8f0fSDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) 290eaaf8f0fSDaniel Vetter return -EINVAL; 291eaaf8f0fSDaniel Vetter 292eaaf8f0fSDaniel Vetter return drm_pci_irq_by_busid(dev, p); 293eaaf8f0fSDaniel Vetter } 294eaaf8f0fSDaniel Vetter 2958da79ccdSDaniel Vetter static void drm_pci_agp_init(struct drm_device *dev) 2968410ea3bSDave Airlie { 297d9906753SDaniel Vetter if (drm_core_check_feature(dev, DRIVER_USE_AGP)) { 2988410ea3bSDave Airlie if (drm_pci_device_is_agp(dev)) 2998410ea3bSDave Airlie dev->agp = drm_agp_init(dev); 30028185647SDaniel Vetter if (dev->agp) { 301f435046dSAndy Lutomirski dev->agp->agp_mtrr = arch_phys_wc_add( 302f435046dSAndy Lutomirski dev->agp->agp_info.aper_base, 3038410ea3bSDave Airlie dev->agp->agp_info.aper_size * 304f435046dSAndy Lutomirski 1024 * 1024); 3058410ea3bSDave Airlie } 3068410ea3bSDave Airlie } 3078410ea3bSDave Airlie } 3088410ea3bSDave Airlie 3094efafebeSDaniel Vetter void drm_pci_agp_destroy(struct drm_device *dev) 31028ec711cSDavid Herrmann { 311d9906753SDaniel Vetter if (dev->agp) { 31228ec711cSDavid Herrmann arch_phys_wc_del(dev->agp->agp_mtrr); 31328ec711cSDavid Herrmann drm_agp_clear(dev); 314d6e4b28bSDaniel Vetter kfree(dev->agp); 31528ec711cSDavid Herrmann dev->agp = NULL; 31628ec711cSDavid Herrmann } 31728ec711cSDavid Herrmann } 31828ec711cSDavid Herrmann 3198410ea3bSDave Airlie static struct drm_bus drm_pci_bus = { 3208410ea3bSDave Airlie .bus_type = DRIVER_BUS_PCI, 3218410ea3bSDave Airlie .get_irq = drm_pci_get_irq, 3228410ea3bSDave Airlie .get_name = drm_pci_get_name, 3238410ea3bSDave Airlie .set_busid = drm_pci_set_busid, 3248410ea3bSDave Airlie .set_unique = drm_pci_set_unique, 3258410ea3bSDave Airlie }; 3268410ea3bSDave Airlie 327dcdb1674SJordan Crouse /** 328dcdb1674SJordan Crouse * Register. 329dcdb1674SJordan Crouse * 330dcdb1674SJordan Crouse * \param pdev - PCI device structure 331dcdb1674SJordan Crouse * \param ent entry from the PCI ID table with device type flags 332dcdb1674SJordan Crouse * \return zero on success or a negative number on failure. 333dcdb1674SJordan Crouse * 334dcdb1674SJordan Crouse * Attempt to gets inter module "drm" information. If we are first 335dcdb1674SJordan Crouse * then register the character device and inter module information. 336dcdb1674SJordan Crouse * Try and register, if we fail to register, backout previous work. 337dcdb1674SJordan Crouse */ 338dcdb1674SJordan Crouse int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, 339dcdb1674SJordan Crouse struct drm_driver *driver) 340dcdb1674SJordan Crouse { 341dcdb1674SJordan Crouse struct drm_device *dev; 342dcdb1674SJordan Crouse int ret; 343dcdb1674SJordan Crouse 344dcdb1674SJordan Crouse DRM_DEBUG("\n"); 345dcdb1674SJordan Crouse 3461bb72532SDavid Herrmann dev = drm_dev_alloc(driver, &pdev->dev); 347dcdb1674SJordan Crouse if (!dev) 348dcdb1674SJordan Crouse return -ENOMEM; 349dcdb1674SJordan Crouse 350dcdb1674SJordan Crouse ret = pci_enable_device(pdev); 351dcdb1674SJordan Crouse if (ret) 352c22f0aceSDavid Herrmann goto err_free; 353dcdb1674SJordan Crouse 354dcdb1674SJordan Crouse dev->pdev = pdev; 355dcdb1674SJordan Crouse #ifdef __alpha__ 356dcdb1674SJordan Crouse dev->hose = pdev->sysdata; 357dcdb1674SJordan Crouse #endif 358dcdb1674SJordan Crouse 359c22f0aceSDavid Herrmann if (drm_core_check_feature(dev, DRIVER_MODESET)) 360dcdb1674SJordan Crouse pci_set_drvdata(pdev, dev); 361c22f0aceSDavid Herrmann 3622c695fa0SDaniel Vetter drm_pci_agp_init(dev); 3632c695fa0SDaniel Vetter 364c22f0aceSDavid Herrmann ret = drm_dev_register(dev, ent->driver_data); 365dcdb1674SJordan Crouse if (ret) 3662c695fa0SDaniel Vetter goto err_agp; 367dcdb1674SJordan Crouse 368dcdb1674SJordan Crouse DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 369dcdb1674SJordan Crouse driver->name, driver->major, driver->minor, driver->patchlevel, 370dcdb1674SJordan Crouse driver->date, pci_name(pdev), dev->primary->index); 371dcdb1674SJordan Crouse 372b3f2333dSDaniel Vetter /* No locking needed since shadow-attach is single-threaded since it may 373b3f2333dSDaniel Vetter * only be called from the per-driver module init hook. */ 374b3f2333dSDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 375b3f2333dSDaniel Vetter list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list); 376b3f2333dSDaniel Vetter 377dcdb1674SJordan Crouse return 0; 378dcdb1674SJordan Crouse 3792c695fa0SDaniel Vetter err_agp: 3802c695fa0SDaniel Vetter drm_pci_agp_destroy(dev); 381dcdb1674SJordan Crouse pci_disable_device(pdev); 382c22f0aceSDavid Herrmann err_free: 383099d1c29SDavid Herrmann drm_dev_unref(dev); 384dcdb1674SJordan Crouse return ret; 385dcdb1674SJordan Crouse } 386dcdb1674SJordan Crouse EXPORT_SYMBOL(drm_get_pci_dev); 387dcdb1674SJordan Crouse 388dcdb1674SJordan Crouse /** 3898410ea3bSDave Airlie * PCI device initialization. Called direct from modules at load time. 390dcdb1674SJordan Crouse * 391dcdb1674SJordan Crouse * \return zero on success or a negative number on failure. 392dcdb1674SJordan Crouse * 393dcdb1674SJordan Crouse * Initializes a drm_device structures,registering the 394dcdb1674SJordan Crouse * stubs and initializing the AGP device. 395dcdb1674SJordan Crouse * 396dcdb1674SJordan Crouse * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and 397dcdb1674SJordan Crouse * after the initialization for driver customization. 398dcdb1674SJordan Crouse */ 3998410ea3bSDave Airlie int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 400dcdb1674SJordan Crouse { 401dcdb1674SJordan Crouse struct pci_dev *pdev = NULL; 402dcdb1674SJordan Crouse const struct pci_device_id *pid; 403dcdb1674SJordan Crouse int i; 404dcdb1674SJordan Crouse 4058410ea3bSDave Airlie DRM_DEBUG("\n"); 4068410ea3bSDave Airlie 4078410ea3bSDave Airlie driver->kdriver.pci = pdriver; 4088410ea3bSDave Airlie driver->bus = &drm_pci_bus; 4098410ea3bSDave Airlie 410dcdb1674SJordan Crouse if (driver->driver_features & DRIVER_MODESET) 4118410ea3bSDave Airlie return pci_register_driver(pdriver); 412dcdb1674SJordan Crouse 413dcdb1674SJordan Crouse /* If not using KMS, fall back to stealth mode manual scanning. */ 414b3f2333dSDaniel Vetter INIT_LIST_HEAD(&driver->legacy_dev_list); 4158410ea3bSDave Airlie for (i = 0; pdriver->id_table[i].vendor != 0; i++) { 4168410ea3bSDave Airlie pid = &pdriver->id_table[i]; 417dcdb1674SJordan Crouse 418dcdb1674SJordan Crouse /* Loop around setting up a DRM device for each PCI device 419dcdb1674SJordan Crouse * matching our ID and device class. If we had the internal 420dcdb1674SJordan Crouse * function that pci_get_subsys and pci_get_class used, we'd 421dcdb1674SJordan Crouse * be able to just pass pid in instead of doing a two-stage 422dcdb1674SJordan Crouse * thing. 423dcdb1674SJordan Crouse */ 424dcdb1674SJordan Crouse pdev = NULL; 425dcdb1674SJordan Crouse while ((pdev = 426dcdb1674SJordan Crouse pci_get_subsys(pid->vendor, pid->device, pid->subvendor, 427dcdb1674SJordan Crouse pid->subdevice, pdev)) != NULL) { 428dcdb1674SJordan Crouse if ((pdev->class & pid->class_mask) != pid->class) 429dcdb1674SJordan Crouse continue; 430dcdb1674SJordan Crouse 431dcdb1674SJordan Crouse /* stealth mode requires a manual probe */ 432dcdb1674SJordan Crouse pci_dev_get(pdev); 433dcdb1674SJordan Crouse drm_get_pci_dev(pdev, pid, driver); 434dcdb1674SJordan Crouse } 435dcdb1674SJordan Crouse } 436dcdb1674SJordan Crouse return 0; 437dcdb1674SJordan Crouse } 438dcdb1674SJordan Crouse 439f4297784SDave Airlie int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask) 440f4297784SDave Airlie { 441f4297784SDave Airlie struct pci_dev *root; 442dd66cc2eSBjorn Helgaas u32 lnkcap, lnkcap2; 443f4297784SDave Airlie 444f4297784SDave Airlie *mask = 0; 445f4297784SDave Airlie if (!dev->pdev) 446f4297784SDave Airlie return -EINVAL; 447f4297784SDave Airlie 448f4297784SDave Airlie root = dev->pdev->bus->self; 449f4297784SDave Airlie 450f4297784SDave Airlie /* we've been informed via and serverworks don't make the cut */ 451f4297784SDave Airlie if (root->vendor == PCI_VENDOR_ID_VIA || 452f4297784SDave Airlie root->vendor == PCI_VENDOR_ID_SERVERWORKS) 453f4297784SDave Airlie return -EINVAL; 454f4297784SDave Airlie 455dd66cc2eSBjorn Helgaas pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap); 456dd66cc2eSBjorn Helgaas pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2); 457f4297784SDave Airlie 458dd66cc2eSBjorn Helgaas if (lnkcap2) { /* PCIe r3.0-compliant */ 459f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB) 460f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_25; 461f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB) 462f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_50; 463f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB) 464f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_80; 465dd66cc2eSBjorn Helgaas } else { /* pre-r3.0 */ 4669fe0423eSBjorn Helgaas if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB) 467f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_25; 4689fe0423eSBjorn Helgaas if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB) 469f8acf6f4SBjorn Helgaas *mask |= (DRM_PCIE_SPEED_25 | DRM_PCIE_SPEED_50); 470f4297784SDave Airlie } 471f4297784SDave Airlie 472f4297784SDave Airlie DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2); 473f4297784SDave Airlie return 0; 474f4297784SDave Airlie } 475f4297784SDave Airlie EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask); 47693711d8bSBjorn Helgaas 47793711d8bSBjorn Helgaas #else 47893711d8bSBjorn Helgaas 47993711d8bSBjorn Helgaas int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 48093711d8bSBjorn Helgaas { 48193711d8bSBjorn Helgaas return -1; 48293711d8bSBjorn Helgaas } 48393711d8bSBjorn Helgaas 4844efafebeSDaniel Vetter void drm_pci_agp_destroy(struct drm_device *dev) {} 485eaaf8f0fSDaniel Vetter 486eaaf8f0fSDaniel Vetter int drm_irq_by_busid(struct drm_device *dev, void *data, 487eaaf8f0fSDaniel Vetter struct drm_file *file_priv) 488eaaf8f0fSDaniel Vetter { 489eaaf8f0fSDaniel Vetter return -EINVAL; 490eaaf8f0fSDaniel Vetter } 49193711d8bSBjorn Helgaas #endif 49293711d8bSBjorn Helgaas 49393711d8bSBjorn Helgaas EXPORT_SYMBOL(drm_pci_init); 49493711d8bSBjorn Helgaas 49593711d8bSBjorn Helgaas /*@}*/ 49693711d8bSBjorn Helgaas void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) 49793711d8bSBjorn Helgaas { 49893711d8bSBjorn Helgaas struct drm_device *dev, *tmp; 49993711d8bSBjorn Helgaas DRM_DEBUG("\n"); 50093711d8bSBjorn Helgaas 50193711d8bSBjorn Helgaas if (driver->driver_features & DRIVER_MODESET) { 50293711d8bSBjorn Helgaas pci_unregister_driver(pdriver); 50393711d8bSBjorn Helgaas } else { 504b3f2333dSDaniel Vetter list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list, 505b3f2333dSDaniel Vetter legacy_dev_list) { 506b3f2333dSDaniel Vetter list_del(&dev->legacy_dev_list); 507c94adc4aSDaniel Vetter drm_put_dev(dev); 508b3f2333dSDaniel Vetter } 50993711d8bSBjorn Helgaas } 51093711d8bSBjorn Helgaas DRM_INFO("Module unloaded\n"); 51193711d8bSBjorn Helgaas } 51293711d8bSBjorn Helgaas EXPORT_SYMBOL(drm_pci_exit); 513