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 const char *drm_pci_get_name(struct drm_device *dev) 1418410ea3bSDave Airlie { 1428410ea3bSDave Airlie struct pci_driver *pdriver = dev->driver->kdriver.pci; 1438410ea3bSDave Airlie return pdriver->name; 1448410ea3bSDave Airlie } 1458410ea3bSDave Airlie 146ea9cbb06SVille Syrjälä static int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) 1478410ea3bSDave Airlie { 1488410ea3bSDave Airlie int len, ret; 1498410ea3bSDave Airlie struct pci_driver *pdriver = dev->driver->kdriver.pci; 1508410ea3bSDave Airlie master->unique_len = 40; 1518410ea3bSDave Airlie master->unique_size = master->unique_len; 1528410ea3bSDave Airlie master->unique = kmalloc(master->unique_size, GFP_KERNEL); 1538410ea3bSDave Airlie if (master->unique == NULL) 1548410ea3bSDave Airlie return -ENOMEM; 1558410ea3bSDave Airlie 1568410ea3bSDave Airlie 1578410ea3bSDave Airlie len = snprintf(master->unique, master->unique_len, 1588410ea3bSDave Airlie "pci:%04x:%02x:%02x.%d", 1598410ea3bSDave Airlie drm_get_pci_domain(dev), 1608410ea3bSDave Airlie dev->pdev->bus->number, 1618410ea3bSDave Airlie PCI_SLOT(dev->pdev->devfn), 1628410ea3bSDave Airlie PCI_FUNC(dev->pdev->devfn)); 1638410ea3bSDave Airlie 1648410ea3bSDave Airlie if (len >= master->unique_len) { 1658410ea3bSDave Airlie DRM_ERROR("buffer overflow"); 1668410ea3bSDave Airlie ret = -EINVAL; 1678410ea3bSDave Airlie goto err; 1688410ea3bSDave Airlie } else 1698410ea3bSDave Airlie master->unique_len = len; 1708410ea3bSDave Airlie 1718410ea3bSDave Airlie dev->devname = 1728410ea3bSDave Airlie kmalloc(strlen(pdriver->name) + 1738410ea3bSDave Airlie master->unique_len + 2, GFP_KERNEL); 1748410ea3bSDave Airlie 1758410ea3bSDave Airlie if (dev->devname == NULL) { 1768410ea3bSDave Airlie ret = -ENOMEM; 1778410ea3bSDave Airlie goto err; 1788410ea3bSDave Airlie } 1798410ea3bSDave Airlie 1808410ea3bSDave Airlie sprintf(dev->devname, "%s@%s", pdriver->name, 1818410ea3bSDave Airlie master->unique); 1828410ea3bSDave Airlie 1838410ea3bSDave Airlie return 0; 1848410ea3bSDave Airlie err: 1858410ea3bSDave Airlie return ret; 1868410ea3bSDave Airlie } 1878410ea3bSDave Airlie 18853bf2a2bSDaniel Vetter int drm_pci_set_unique(struct drm_device *dev, 1898410ea3bSDave Airlie struct drm_master *master, 1908410ea3bSDave Airlie struct drm_unique *u) 1918410ea3bSDave Airlie { 1928410ea3bSDave Airlie int domain, bus, slot, func, ret; 1938410ea3bSDave Airlie const char *bus_name; 1948410ea3bSDave Airlie 1958410ea3bSDave Airlie master->unique_len = u->unique_len; 1968410ea3bSDave Airlie master->unique_size = u->unique_len + 1; 1978410ea3bSDave Airlie master->unique = kmalloc(master->unique_size, GFP_KERNEL); 1988410ea3bSDave Airlie if (!master->unique) { 1998410ea3bSDave Airlie ret = -ENOMEM; 2008410ea3bSDave Airlie goto err; 2018410ea3bSDave Airlie } 2028410ea3bSDave Airlie 2038410ea3bSDave Airlie if (copy_from_user(master->unique, u->unique, master->unique_len)) { 2048410ea3bSDave Airlie ret = -EFAULT; 2058410ea3bSDave Airlie goto err; 2068410ea3bSDave Airlie } 2078410ea3bSDave Airlie 2088410ea3bSDave Airlie master->unique[master->unique_len] = '\0'; 2098410ea3bSDave Airlie 2108410ea3bSDave Airlie bus_name = dev->driver->bus->get_name(dev); 2118410ea3bSDave Airlie dev->devname = kmalloc(strlen(bus_name) + 2128410ea3bSDave Airlie strlen(master->unique) + 2, GFP_KERNEL); 2138410ea3bSDave Airlie if (!dev->devname) { 2148410ea3bSDave Airlie ret = -ENOMEM; 2158410ea3bSDave Airlie goto err; 2168410ea3bSDave Airlie } 2178410ea3bSDave Airlie 2188410ea3bSDave Airlie sprintf(dev->devname, "%s@%s", bus_name, 2198410ea3bSDave Airlie master->unique); 2208410ea3bSDave Airlie 2218410ea3bSDave Airlie /* Return error if the busid submitted doesn't match the device's actual 2228410ea3bSDave Airlie * busid. 2238410ea3bSDave Airlie */ 2248410ea3bSDave Airlie ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func); 2258410ea3bSDave Airlie if (ret != 3) { 2268410ea3bSDave Airlie ret = -EINVAL; 2278410ea3bSDave Airlie goto err; 2288410ea3bSDave Airlie } 2298410ea3bSDave Airlie 2308410ea3bSDave Airlie domain = bus >> 8; 2318410ea3bSDave Airlie bus &= 0xff; 2328410ea3bSDave Airlie 2338410ea3bSDave Airlie if ((domain != drm_get_pci_domain(dev)) || 2348410ea3bSDave Airlie (bus != dev->pdev->bus->number) || 2358410ea3bSDave Airlie (slot != PCI_SLOT(dev->pdev->devfn)) || 2368410ea3bSDave Airlie (func != PCI_FUNC(dev->pdev->devfn))) { 2378410ea3bSDave Airlie ret = -EINVAL; 2388410ea3bSDave Airlie goto err; 2398410ea3bSDave Airlie } 2408410ea3bSDave Airlie return 0; 2418410ea3bSDave Airlie err: 2428410ea3bSDave Airlie return ret; 2438410ea3bSDave Airlie } 2448410ea3bSDave Airlie 24545e97ab6SWolfram Sang static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) 2468410ea3bSDave Airlie { 2478410ea3bSDave Airlie if ((p->busnum >> 8) != drm_get_pci_domain(dev) || 2488410ea3bSDave Airlie (p->busnum & 0xff) != dev->pdev->bus->number || 2498410ea3bSDave Airlie p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) 2508410ea3bSDave Airlie return -EINVAL; 2518410ea3bSDave Airlie 2528410ea3bSDave Airlie p->irq = dev->pdev->irq; 2538410ea3bSDave Airlie 2548410ea3bSDave Airlie DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, 2558410ea3bSDave Airlie p->irq); 2568410ea3bSDave Airlie return 0; 2578410ea3bSDave Airlie } 2588410ea3bSDave Airlie 259eaaf8f0fSDaniel Vetter /** 260eaaf8f0fSDaniel Vetter * Get interrupt from bus id. 261eaaf8f0fSDaniel Vetter * 262eaaf8f0fSDaniel Vetter * \param inode device inode. 263eaaf8f0fSDaniel Vetter * \param file_priv DRM file private. 264eaaf8f0fSDaniel Vetter * \param cmd command. 265eaaf8f0fSDaniel Vetter * \param arg user argument, pointing to a drm_irq_busid structure. 266eaaf8f0fSDaniel Vetter * \return zero on success or a negative number on failure. 267eaaf8f0fSDaniel Vetter * 268eaaf8f0fSDaniel Vetter * Finds the PCI device with the specified bus id and gets its IRQ number. 269eaaf8f0fSDaniel Vetter * This IOCTL is deprecated, and will now return EINVAL for any busid not equal 270eaaf8f0fSDaniel Vetter * to that of the device that this DRM instance attached to. 271eaaf8f0fSDaniel Vetter */ 272eaaf8f0fSDaniel Vetter int drm_irq_by_busid(struct drm_device *dev, void *data, 273eaaf8f0fSDaniel Vetter struct drm_file *file_priv) 274eaaf8f0fSDaniel Vetter { 275eaaf8f0fSDaniel Vetter struct drm_irq_busid *p = data; 276eaaf8f0fSDaniel Vetter 277eaaf8f0fSDaniel Vetter if (drm_core_check_feature(dev, DRIVER_MODESET)) 278eaaf8f0fSDaniel Vetter return -EINVAL; 279eaaf8f0fSDaniel Vetter 280eaaf8f0fSDaniel Vetter /* UMS was only ever support on PCI devices. */ 281eaaf8f0fSDaniel Vetter if (WARN_ON(!dev->pdev)) 282eaaf8f0fSDaniel Vetter return -EINVAL; 283eaaf8f0fSDaniel Vetter 284eaaf8f0fSDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) 285eaaf8f0fSDaniel Vetter return -EINVAL; 286eaaf8f0fSDaniel Vetter 287eaaf8f0fSDaniel Vetter return drm_pci_irq_by_busid(dev, p); 288eaaf8f0fSDaniel Vetter } 289eaaf8f0fSDaniel Vetter 2908da79ccdSDaniel Vetter static void drm_pci_agp_init(struct drm_device *dev) 2918410ea3bSDave Airlie { 292d9906753SDaniel Vetter if (drm_core_check_feature(dev, DRIVER_USE_AGP)) { 2938410ea3bSDave Airlie if (drm_pci_device_is_agp(dev)) 2948410ea3bSDave Airlie dev->agp = drm_agp_init(dev); 29528185647SDaniel Vetter if (dev->agp) { 296f435046dSAndy Lutomirski dev->agp->agp_mtrr = arch_phys_wc_add( 297f435046dSAndy Lutomirski dev->agp->agp_info.aper_base, 2988410ea3bSDave Airlie dev->agp->agp_info.aper_size * 299f435046dSAndy Lutomirski 1024 * 1024); 3008410ea3bSDave Airlie } 3018410ea3bSDave Airlie } 3028410ea3bSDave Airlie } 3038410ea3bSDave Airlie 3044efafebeSDaniel Vetter void drm_pci_agp_destroy(struct drm_device *dev) 30528ec711cSDavid Herrmann { 306d9906753SDaniel Vetter if (dev->agp) { 30728ec711cSDavid Herrmann arch_phys_wc_del(dev->agp->agp_mtrr); 30828ec711cSDavid Herrmann drm_agp_clear(dev); 309d6e4b28bSDaniel Vetter kfree(dev->agp); 31028ec711cSDavid Herrmann dev->agp = NULL; 31128ec711cSDavid Herrmann } 31228ec711cSDavid Herrmann } 31328ec711cSDavid Herrmann 3148410ea3bSDave Airlie static struct drm_bus drm_pci_bus = { 3158410ea3bSDave Airlie .get_name = drm_pci_get_name, 3168410ea3bSDave Airlie .set_busid = drm_pci_set_busid, 3178410ea3bSDave Airlie }; 3188410ea3bSDave Airlie 319dcdb1674SJordan Crouse /** 320dcdb1674SJordan Crouse * Register. 321dcdb1674SJordan Crouse * 322dcdb1674SJordan Crouse * \param pdev - PCI device structure 323dcdb1674SJordan Crouse * \param ent entry from the PCI ID table with device type flags 324dcdb1674SJordan Crouse * \return zero on success or a negative number on failure. 325dcdb1674SJordan Crouse * 326dcdb1674SJordan Crouse * Attempt to gets inter module "drm" information. If we are first 327dcdb1674SJordan Crouse * then register the character device and inter module information. 328dcdb1674SJordan Crouse * Try and register, if we fail to register, backout previous work. 329dcdb1674SJordan Crouse */ 330dcdb1674SJordan Crouse int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, 331dcdb1674SJordan Crouse struct drm_driver *driver) 332dcdb1674SJordan Crouse { 333dcdb1674SJordan Crouse struct drm_device *dev; 334dcdb1674SJordan Crouse int ret; 335dcdb1674SJordan Crouse 336dcdb1674SJordan Crouse DRM_DEBUG("\n"); 337dcdb1674SJordan Crouse 3381bb72532SDavid Herrmann dev = drm_dev_alloc(driver, &pdev->dev); 339dcdb1674SJordan Crouse if (!dev) 340dcdb1674SJordan Crouse return -ENOMEM; 341dcdb1674SJordan Crouse 342dcdb1674SJordan Crouse ret = pci_enable_device(pdev); 343dcdb1674SJordan Crouse if (ret) 344c22f0aceSDavid Herrmann goto err_free; 345dcdb1674SJordan Crouse 346dcdb1674SJordan Crouse dev->pdev = pdev; 347dcdb1674SJordan Crouse #ifdef __alpha__ 348dcdb1674SJordan Crouse dev->hose = pdev->sysdata; 349dcdb1674SJordan Crouse #endif 350dcdb1674SJordan Crouse 351c22f0aceSDavid Herrmann if (drm_core_check_feature(dev, DRIVER_MODESET)) 352dcdb1674SJordan Crouse pci_set_drvdata(pdev, dev); 353c22f0aceSDavid Herrmann 3542c695fa0SDaniel Vetter drm_pci_agp_init(dev); 3552c695fa0SDaniel Vetter 356c22f0aceSDavid Herrmann ret = drm_dev_register(dev, ent->driver_data); 357dcdb1674SJordan Crouse if (ret) 3582c695fa0SDaniel Vetter goto err_agp; 359dcdb1674SJordan Crouse 360dcdb1674SJordan Crouse DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 361dcdb1674SJordan Crouse driver->name, driver->major, driver->minor, driver->patchlevel, 362dcdb1674SJordan Crouse driver->date, pci_name(pdev), dev->primary->index); 363dcdb1674SJordan Crouse 364b3f2333dSDaniel Vetter /* No locking needed since shadow-attach is single-threaded since it may 365b3f2333dSDaniel Vetter * only be called from the per-driver module init hook. */ 366b3f2333dSDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 367b3f2333dSDaniel Vetter list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list); 368b3f2333dSDaniel Vetter 369dcdb1674SJordan Crouse return 0; 370dcdb1674SJordan Crouse 3712c695fa0SDaniel Vetter err_agp: 3722c695fa0SDaniel Vetter drm_pci_agp_destroy(dev); 373dcdb1674SJordan Crouse pci_disable_device(pdev); 374c22f0aceSDavid Herrmann err_free: 375099d1c29SDavid Herrmann drm_dev_unref(dev); 376dcdb1674SJordan Crouse return ret; 377dcdb1674SJordan Crouse } 378dcdb1674SJordan Crouse EXPORT_SYMBOL(drm_get_pci_dev); 379dcdb1674SJordan Crouse 380dcdb1674SJordan Crouse /** 3818410ea3bSDave Airlie * PCI device initialization. Called direct from modules at load time. 382dcdb1674SJordan Crouse * 383dcdb1674SJordan Crouse * \return zero on success or a negative number on failure. 384dcdb1674SJordan Crouse * 385dcdb1674SJordan Crouse * Initializes a drm_device structures,registering the 386dcdb1674SJordan Crouse * stubs and initializing the AGP device. 387dcdb1674SJordan Crouse * 388dcdb1674SJordan Crouse * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and 389dcdb1674SJordan Crouse * after the initialization for driver customization. 390dcdb1674SJordan Crouse */ 3918410ea3bSDave Airlie int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 392dcdb1674SJordan Crouse { 393dcdb1674SJordan Crouse struct pci_dev *pdev = NULL; 394dcdb1674SJordan Crouse const struct pci_device_id *pid; 395dcdb1674SJordan Crouse int i; 396dcdb1674SJordan Crouse 3978410ea3bSDave Airlie DRM_DEBUG("\n"); 3988410ea3bSDave Airlie 3998410ea3bSDave Airlie driver->kdriver.pci = pdriver; 4008410ea3bSDave Airlie driver->bus = &drm_pci_bus; 4018410ea3bSDave Airlie 402dcdb1674SJordan Crouse if (driver->driver_features & DRIVER_MODESET) 4038410ea3bSDave Airlie return pci_register_driver(pdriver); 404dcdb1674SJordan Crouse 405dcdb1674SJordan Crouse /* If not using KMS, fall back to stealth mode manual scanning. */ 406b3f2333dSDaniel Vetter INIT_LIST_HEAD(&driver->legacy_dev_list); 4078410ea3bSDave Airlie for (i = 0; pdriver->id_table[i].vendor != 0; i++) { 4088410ea3bSDave Airlie pid = &pdriver->id_table[i]; 409dcdb1674SJordan Crouse 410dcdb1674SJordan Crouse /* Loop around setting up a DRM device for each PCI device 411dcdb1674SJordan Crouse * matching our ID and device class. If we had the internal 412dcdb1674SJordan Crouse * function that pci_get_subsys and pci_get_class used, we'd 413dcdb1674SJordan Crouse * be able to just pass pid in instead of doing a two-stage 414dcdb1674SJordan Crouse * thing. 415dcdb1674SJordan Crouse */ 416dcdb1674SJordan Crouse pdev = NULL; 417dcdb1674SJordan Crouse while ((pdev = 418dcdb1674SJordan Crouse pci_get_subsys(pid->vendor, pid->device, pid->subvendor, 419dcdb1674SJordan Crouse pid->subdevice, pdev)) != NULL) { 420dcdb1674SJordan Crouse if ((pdev->class & pid->class_mask) != pid->class) 421dcdb1674SJordan Crouse continue; 422dcdb1674SJordan Crouse 423dcdb1674SJordan Crouse /* stealth mode requires a manual probe */ 424dcdb1674SJordan Crouse pci_dev_get(pdev); 425dcdb1674SJordan Crouse drm_get_pci_dev(pdev, pid, driver); 426dcdb1674SJordan Crouse } 427dcdb1674SJordan Crouse } 428dcdb1674SJordan Crouse return 0; 429dcdb1674SJordan Crouse } 430dcdb1674SJordan Crouse 431f4297784SDave Airlie int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask) 432f4297784SDave Airlie { 433f4297784SDave Airlie struct pci_dev *root; 434dd66cc2eSBjorn Helgaas u32 lnkcap, lnkcap2; 435f4297784SDave Airlie 436f4297784SDave Airlie *mask = 0; 437f4297784SDave Airlie if (!dev->pdev) 438f4297784SDave Airlie return -EINVAL; 439f4297784SDave Airlie 440f4297784SDave Airlie root = dev->pdev->bus->self; 441f4297784SDave Airlie 442f4297784SDave Airlie /* we've been informed via and serverworks don't make the cut */ 443f4297784SDave Airlie if (root->vendor == PCI_VENDOR_ID_VIA || 444f4297784SDave Airlie root->vendor == PCI_VENDOR_ID_SERVERWORKS) 445f4297784SDave Airlie return -EINVAL; 446f4297784SDave Airlie 447dd66cc2eSBjorn Helgaas pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap); 448dd66cc2eSBjorn Helgaas pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2); 449f4297784SDave Airlie 450dd66cc2eSBjorn Helgaas if (lnkcap2) { /* PCIe r3.0-compliant */ 451f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB) 452f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_25; 453f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB) 454f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_50; 455f4297784SDave Airlie if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB) 456f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_80; 457dd66cc2eSBjorn Helgaas } else { /* pre-r3.0 */ 4589fe0423eSBjorn Helgaas if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB) 459f4297784SDave Airlie *mask |= DRM_PCIE_SPEED_25; 4609fe0423eSBjorn Helgaas if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB) 461f8acf6f4SBjorn Helgaas *mask |= (DRM_PCIE_SPEED_25 | DRM_PCIE_SPEED_50); 462f4297784SDave Airlie } 463f4297784SDave Airlie 464f4297784SDave Airlie DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2); 465f4297784SDave Airlie return 0; 466f4297784SDave Airlie } 467f4297784SDave Airlie EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask); 46893711d8bSBjorn Helgaas 46993711d8bSBjorn Helgaas #else 47093711d8bSBjorn Helgaas 47193711d8bSBjorn Helgaas int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 47293711d8bSBjorn Helgaas { 47393711d8bSBjorn Helgaas return -1; 47493711d8bSBjorn Helgaas } 47593711d8bSBjorn Helgaas 4764efafebeSDaniel Vetter void drm_pci_agp_destroy(struct drm_device *dev) {} 477eaaf8f0fSDaniel Vetter 478eaaf8f0fSDaniel Vetter int drm_irq_by_busid(struct drm_device *dev, void *data, 479eaaf8f0fSDaniel Vetter struct drm_file *file_priv) 480eaaf8f0fSDaniel Vetter { 481eaaf8f0fSDaniel Vetter return -EINVAL; 482eaaf8f0fSDaniel Vetter } 48353bf2a2bSDaniel Vetter 48453bf2a2bSDaniel Vetter int drm_pci_set_unique(struct drm_device *dev, 48553bf2a2bSDaniel Vetter struct drm_master *master, 48653bf2a2bSDaniel Vetter struct drm_unique *u) 48753bf2a2bSDaniel Vetter { 48853bf2a2bSDaniel Vetter return -EINVAL; 48953bf2a2bSDaniel Vetter } 49093711d8bSBjorn Helgaas #endif 49193711d8bSBjorn Helgaas 49293711d8bSBjorn Helgaas EXPORT_SYMBOL(drm_pci_init); 49393711d8bSBjorn Helgaas 49493711d8bSBjorn Helgaas /*@}*/ 49593711d8bSBjorn Helgaas void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) 49693711d8bSBjorn Helgaas { 49793711d8bSBjorn Helgaas struct drm_device *dev, *tmp; 49893711d8bSBjorn Helgaas DRM_DEBUG("\n"); 49993711d8bSBjorn Helgaas 50093711d8bSBjorn Helgaas if (driver->driver_features & DRIVER_MODESET) { 50193711d8bSBjorn Helgaas pci_unregister_driver(pdriver); 50293711d8bSBjorn Helgaas } else { 503b3f2333dSDaniel Vetter list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list, 504b3f2333dSDaniel Vetter legacy_dev_list) { 505b3f2333dSDaniel Vetter list_del(&dev->legacy_dev_list); 506c94adc4aSDaniel Vetter drm_put_dev(dev); 507b3f2333dSDaniel Vetter } 50893711d8bSBjorn Helgaas } 50993711d8bSBjorn Helgaas DRM_INFO("Module unloaded\n"); 51093711d8bSBjorn Helgaas } 51193711d8bSBjorn Helgaas EXPORT_SYMBOL(drm_pci_exit); 512