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> 42c0e09200SDave Airlie #include "drmP.h" 43c0e09200SDave Airlie 44c0e09200SDave Airlie /**********************************************************************/ 45c0e09200SDave Airlie /** \name PCI memory */ 46c0e09200SDave Airlie /*@{*/ 47c0e09200SDave Airlie 48c0e09200SDave Airlie /** 49c0e09200SDave Airlie * \brief Allocate a PCI consistent memory block, for DMA. 50c0e09200SDave Airlie */ 51e6be8d9dSZhenyu Wang drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align) 52c0e09200SDave Airlie { 53c0e09200SDave Airlie drm_dma_handle_t *dmah; 54c0e09200SDave Airlie #if 1 55c0e09200SDave Airlie unsigned long addr; 56c0e09200SDave Airlie size_t sz; 57c0e09200SDave Airlie #endif 58c0e09200SDave Airlie 59c0e09200SDave Airlie /* pci_alloc_consistent only guarantees alignment to the smallest 60c0e09200SDave Airlie * PAGE_SIZE order which is greater than or equal to the requested size. 61c0e09200SDave Airlie * Return NULL here for now to make sure nobody tries for larger alignment 62c0e09200SDave Airlie */ 63c0e09200SDave Airlie if (align > size) 64c0e09200SDave Airlie return NULL; 65c0e09200SDave Airlie 66c0e09200SDave Airlie dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL); 67c0e09200SDave Airlie if (!dmah) 68c0e09200SDave Airlie return NULL; 69c0e09200SDave Airlie 70c0e09200SDave Airlie dmah->size = size; 71c0e09200SDave Airlie dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP); 72c0e09200SDave Airlie 73c0e09200SDave Airlie if (dmah->vaddr == NULL) { 74c0e09200SDave Airlie kfree(dmah); 75c0e09200SDave Airlie return NULL; 76c0e09200SDave Airlie } 77c0e09200SDave Airlie 78c0e09200SDave Airlie memset(dmah->vaddr, 0, size); 79c0e09200SDave Airlie 80c0e09200SDave Airlie /* XXX - Is virt_to_page() legal for consistent mem? */ 81c0e09200SDave Airlie /* Reserve */ 82c0e09200SDave Airlie for (addr = (unsigned long)dmah->vaddr, sz = size; 83c0e09200SDave Airlie sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { 84c0e09200SDave Airlie SetPageReserved(virt_to_page(addr)); 85c0e09200SDave Airlie } 86c0e09200SDave Airlie 87c0e09200SDave Airlie return dmah; 88c0e09200SDave Airlie } 89c0e09200SDave Airlie 90c0e09200SDave Airlie EXPORT_SYMBOL(drm_pci_alloc); 91c0e09200SDave Airlie 92c0e09200SDave Airlie /** 93c0e09200SDave Airlie * \brief Free a PCI consistent memory block without freeing its descriptor. 94c0e09200SDave Airlie * 95c0e09200SDave Airlie * This function is for internal use in the Linux-specific DRM core code. 96c0e09200SDave Airlie */ 97c0e09200SDave Airlie void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) 98c0e09200SDave Airlie { 99c0e09200SDave Airlie #if 1 100c0e09200SDave Airlie unsigned long addr; 101c0e09200SDave Airlie size_t sz; 102c0e09200SDave Airlie #endif 103c0e09200SDave Airlie 1049a298b2aSEric Anholt if (dmah->vaddr) { 105c0e09200SDave Airlie /* XXX - Is virt_to_page() legal for consistent mem? */ 106c0e09200SDave Airlie /* Unreserve */ 107c0e09200SDave Airlie for (addr = (unsigned long)dmah->vaddr, sz = dmah->size; 108c0e09200SDave Airlie sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { 109c0e09200SDave Airlie ClearPageReserved(virt_to_page(addr)); 110c0e09200SDave Airlie } 111c0e09200SDave Airlie dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, 112c0e09200SDave Airlie dmah->busaddr); 113c0e09200SDave Airlie } 114c0e09200SDave Airlie } 115c0e09200SDave Airlie 116c0e09200SDave Airlie /** 117c0e09200SDave Airlie * \brief Free a PCI consistent memory block 118c0e09200SDave Airlie */ 119c0e09200SDave Airlie void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) 120c0e09200SDave Airlie { 121c0e09200SDave Airlie __drm_pci_free(dev, dmah); 122c0e09200SDave Airlie kfree(dmah); 123c0e09200SDave Airlie } 124c0e09200SDave Airlie 125c0e09200SDave Airlie EXPORT_SYMBOL(drm_pci_free); 126c0e09200SDave Airlie 127dcdb1674SJordan Crouse #ifdef CONFIG_PCI 1288410ea3bSDave Airlie 1298410ea3bSDave Airlie static int drm_get_pci_domain(struct drm_device *dev) 1308410ea3bSDave Airlie { 1318410ea3bSDave Airlie #ifndef __alpha__ 1328410ea3bSDave Airlie /* For historical reasons, drm_get_pci_domain() is busticated 1338410ea3bSDave Airlie * on most archs and has to remain so for userspace interface 1348410ea3bSDave Airlie * < 1.4, except on alpha which was right from the beginning 1358410ea3bSDave Airlie */ 1368410ea3bSDave Airlie if (dev->if_version < 0x10004) 1378410ea3bSDave Airlie return 0; 1388410ea3bSDave Airlie #endif /* __alpha__ */ 1398410ea3bSDave Airlie 1408410ea3bSDave Airlie return pci_domain_nr(dev->pdev->bus); 1418410ea3bSDave Airlie } 1428410ea3bSDave Airlie 1438410ea3bSDave Airlie static int drm_pci_get_irq(struct drm_device *dev) 1448410ea3bSDave Airlie { 1458410ea3bSDave Airlie return dev->pdev->irq; 1468410ea3bSDave Airlie } 1478410ea3bSDave Airlie 1488410ea3bSDave Airlie static const char *drm_pci_get_name(struct drm_device *dev) 1498410ea3bSDave Airlie { 1508410ea3bSDave Airlie struct pci_driver *pdriver = dev->driver->kdriver.pci; 1518410ea3bSDave Airlie return pdriver->name; 1528410ea3bSDave Airlie } 1538410ea3bSDave Airlie 1548410ea3bSDave Airlie int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) 1558410ea3bSDave Airlie { 1568410ea3bSDave Airlie int len, ret; 1578410ea3bSDave Airlie struct pci_driver *pdriver = dev->driver->kdriver.pci; 1588410ea3bSDave Airlie master->unique_len = 40; 1598410ea3bSDave Airlie master->unique_size = master->unique_len; 1608410ea3bSDave Airlie master->unique = kmalloc(master->unique_size, GFP_KERNEL); 1618410ea3bSDave Airlie if (master->unique == NULL) 1628410ea3bSDave Airlie return -ENOMEM; 1638410ea3bSDave Airlie 1648410ea3bSDave Airlie 1658410ea3bSDave Airlie len = snprintf(master->unique, master->unique_len, 1668410ea3bSDave Airlie "pci:%04x:%02x:%02x.%d", 1678410ea3bSDave Airlie drm_get_pci_domain(dev), 1688410ea3bSDave Airlie dev->pdev->bus->number, 1698410ea3bSDave Airlie PCI_SLOT(dev->pdev->devfn), 1708410ea3bSDave Airlie PCI_FUNC(dev->pdev->devfn)); 1718410ea3bSDave Airlie 1728410ea3bSDave Airlie if (len >= master->unique_len) { 1738410ea3bSDave Airlie DRM_ERROR("buffer overflow"); 1748410ea3bSDave Airlie ret = -EINVAL; 1758410ea3bSDave Airlie goto err; 1768410ea3bSDave Airlie } else 1778410ea3bSDave Airlie master->unique_len = len; 1788410ea3bSDave Airlie 1798410ea3bSDave Airlie dev->devname = 1808410ea3bSDave Airlie kmalloc(strlen(pdriver->name) + 1818410ea3bSDave Airlie master->unique_len + 2, GFP_KERNEL); 1828410ea3bSDave Airlie 1838410ea3bSDave Airlie if (dev->devname == NULL) { 1848410ea3bSDave Airlie ret = -ENOMEM; 1858410ea3bSDave Airlie goto err; 1868410ea3bSDave Airlie } 1878410ea3bSDave Airlie 1888410ea3bSDave Airlie sprintf(dev->devname, "%s@%s", pdriver->name, 1898410ea3bSDave Airlie master->unique); 1908410ea3bSDave Airlie 1918410ea3bSDave Airlie return 0; 1928410ea3bSDave Airlie err: 1938410ea3bSDave Airlie return ret; 1948410ea3bSDave Airlie } 1958410ea3bSDave Airlie 1968410ea3bSDave Airlie int drm_pci_set_unique(struct drm_device *dev, 1978410ea3bSDave Airlie struct drm_master *master, 1988410ea3bSDave Airlie struct drm_unique *u) 1998410ea3bSDave Airlie { 2008410ea3bSDave Airlie int domain, bus, slot, func, ret; 2018410ea3bSDave Airlie const char *bus_name; 2028410ea3bSDave Airlie 2038410ea3bSDave Airlie master->unique_len = u->unique_len; 2048410ea3bSDave Airlie master->unique_size = u->unique_len + 1; 2058410ea3bSDave Airlie master->unique = kmalloc(master->unique_size, GFP_KERNEL); 2068410ea3bSDave Airlie if (!master->unique) { 2078410ea3bSDave Airlie ret = -ENOMEM; 2088410ea3bSDave Airlie goto err; 2098410ea3bSDave Airlie } 2108410ea3bSDave Airlie 2118410ea3bSDave Airlie if (copy_from_user(master->unique, u->unique, master->unique_len)) { 2128410ea3bSDave Airlie ret = -EFAULT; 2138410ea3bSDave Airlie goto err; 2148410ea3bSDave Airlie } 2158410ea3bSDave Airlie 2168410ea3bSDave Airlie master->unique[master->unique_len] = '\0'; 2178410ea3bSDave Airlie 2188410ea3bSDave Airlie bus_name = dev->driver->bus->get_name(dev); 2198410ea3bSDave Airlie dev->devname = kmalloc(strlen(bus_name) + 2208410ea3bSDave Airlie strlen(master->unique) + 2, GFP_KERNEL); 2218410ea3bSDave Airlie if (!dev->devname) { 2228410ea3bSDave Airlie ret = -ENOMEM; 2238410ea3bSDave Airlie goto err; 2248410ea3bSDave Airlie } 2258410ea3bSDave Airlie 2268410ea3bSDave Airlie sprintf(dev->devname, "%s@%s", bus_name, 2278410ea3bSDave Airlie master->unique); 2288410ea3bSDave Airlie 2298410ea3bSDave Airlie /* Return error if the busid submitted doesn't match the device's actual 2308410ea3bSDave Airlie * busid. 2318410ea3bSDave Airlie */ 2328410ea3bSDave Airlie ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func); 2338410ea3bSDave Airlie if (ret != 3) { 2348410ea3bSDave Airlie ret = -EINVAL; 2358410ea3bSDave Airlie goto err; 2368410ea3bSDave Airlie } 2378410ea3bSDave Airlie 2388410ea3bSDave Airlie domain = bus >> 8; 2398410ea3bSDave Airlie bus &= 0xff; 2408410ea3bSDave Airlie 2418410ea3bSDave Airlie if ((domain != drm_get_pci_domain(dev)) || 2428410ea3bSDave Airlie (bus != dev->pdev->bus->number) || 2438410ea3bSDave Airlie (slot != PCI_SLOT(dev->pdev->devfn)) || 2448410ea3bSDave Airlie (func != PCI_FUNC(dev->pdev->devfn))) { 2458410ea3bSDave Airlie ret = -EINVAL; 2468410ea3bSDave Airlie goto err; 2478410ea3bSDave Airlie } 2488410ea3bSDave Airlie return 0; 2498410ea3bSDave Airlie err: 2508410ea3bSDave Airlie return ret; 2518410ea3bSDave Airlie } 2528410ea3bSDave Airlie 2538410ea3bSDave Airlie 25445e97ab6SWolfram Sang static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) 2558410ea3bSDave Airlie { 2568410ea3bSDave Airlie if ((p->busnum >> 8) != drm_get_pci_domain(dev) || 2578410ea3bSDave Airlie (p->busnum & 0xff) != dev->pdev->bus->number || 2588410ea3bSDave Airlie p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) 2598410ea3bSDave Airlie return -EINVAL; 2608410ea3bSDave Airlie 2618410ea3bSDave Airlie p->irq = dev->pdev->irq; 2628410ea3bSDave Airlie 2638410ea3bSDave Airlie DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, 2648410ea3bSDave Airlie p->irq); 2658410ea3bSDave Airlie return 0; 2668410ea3bSDave Airlie } 2678410ea3bSDave Airlie 2688410ea3bSDave Airlie int drm_pci_agp_init(struct drm_device *dev) 2698410ea3bSDave Airlie { 2708410ea3bSDave Airlie if (drm_core_has_AGP(dev)) { 2718410ea3bSDave Airlie if (drm_pci_device_is_agp(dev)) 2728410ea3bSDave Airlie dev->agp = drm_agp_init(dev); 2738410ea3bSDave Airlie if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP) 2748410ea3bSDave Airlie && (dev->agp == NULL)) { 2758410ea3bSDave Airlie DRM_ERROR("Cannot initialize the agpgart module.\n"); 2768410ea3bSDave Airlie return -EINVAL; 2778410ea3bSDave Airlie } 2788410ea3bSDave Airlie if (drm_core_has_MTRR(dev)) { 2798410ea3bSDave Airlie if (dev->agp) 2808410ea3bSDave Airlie dev->agp->agp_mtrr = 2818410ea3bSDave Airlie mtrr_add(dev->agp->agp_info.aper_base, 2828410ea3bSDave Airlie dev->agp->agp_info.aper_size * 2838410ea3bSDave Airlie 1024 * 1024, MTRR_TYPE_WRCOMB, 1); 2848410ea3bSDave Airlie } 2858410ea3bSDave Airlie } 2868410ea3bSDave Airlie return 0; 2878410ea3bSDave Airlie } 2888410ea3bSDave Airlie 2898410ea3bSDave Airlie static struct drm_bus drm_pci_bus = { 2908410ea3bSDave Airlie .bus_type = DRIVER_BUS_PCI, 2918410ea3bSDave Airlie .get_irq = drm_pci_get_irq, 2928410ea3bSDave Airlie .get_name = drm_pci_get_name, 2938410ea3bSDave Airlie .set_busid = drm_pci_set_busid, 2948410ea3bSDave Airlie .set_unique = drm_pci_set_unique, 29545e97ab6SWolfram Sang .irq_by_busid = drm_pci_irq_by_busid, 2968410ea3bSDave Airlie .agp_init = drm_pci_agp_init, 2978410ea3bSDave Airlie }; 2988410ea3bSDave Airlie 299dcdb1674SJordan Crouse /** 300dcdb1674SJordan Crouse * Register. 301dcdb1674SJordan Crouse * 302dcdb1674SJordan Crouse * \param pdev - PCI device structure 303dcdb1674SJordan Crouse * \param ent entry from the PCI ID table with device type flags 304dcdb1674SJordan Crouse * \return zero on success or a negative number on failure. 305dcdb1674SJordan Crouse * 306dcdb1674SJordan Crouse * Attempt to gets inter module "drm" information. If we are first 307dcdb1674SJordan Crouse * then register the character device and inter module information. 308dcdb1674SJordan Crouse * Try and register, if we fail to register, backout previous work. 309dcdb1674SJordan Crouse */ 310dcdb1674SJordan Crouse int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, 311dcdb1674SJordan Crouse struct drm_driver *driver) 312dcdb1674SJordan Crouse { 313dcdb1674SJordan Crouse struct drm_device *dev; 314dcdb1674SJordan Crouse int ret; 315dcdb1674SJordan Crouse 316dcdb1674SJordan Crouse DRM_DEBUG("\n"); 317dcdb1674SJordan Crouse 318dcdb1674SJordan Crouse dev = kzalloc(sizeof(*dev), GFP_KERNEL); 319dcdb1674SJordan Crouse if (!dev) 320dcdb1674SJordan Crouse return -ENOMEM; 321dcdb1674SJordan Crouse 322dcdb1674SJordan Crouse ret = pci_enable_device(pdev); 323dcdb1674SJordan Crouse if (ret) 324dcdb1674SJordan Crouse goto err_g1; 325dcdb1674SJordan Crouse 326dcdb1674SJordan Crouse pci_set_master(pdev); 327dcdb1674SJordan Crouse 328dcdb1674SJordan Crouse dev->pdev = pdev; 329dcdb1674SJordan Crouse dev->dev = &pdev->dev; 330dcdb1674SJordan Crouse 331dcdb1674SJordan Crouse dev->pci_device = pdev->device; 332dcdb1674SJordan Crouse dev->pci_vendor = pdev->vendor; 333dcdb1674SJordan Crouse 334dcdb1674SJordan Crouse #ifdef __alpha__ 335dcdb1674SJordan Crouse dev->hose = pdev->sysdata; 336dcdb1674SJordan Crouse #endif 337dcdb1674SJordan Crouse 338b64c115eSDave Airlie mutex_lock(&drm_global_mutex); 339b64c115eSDave Airlie 340dcdb1674SJordan Crouse if ((ret = drm_fill_in_dev(dev, ent, driver))) { 341dcdb1674SJordan Crouse printk(KERN_ERR "DRM: Fill_in_dev failed.\n"); 342dcdb1674SJordan Crouse goto err_g2; 343dcdb1674SJordan Crouse } 344dcdb1674SJordan Crouse 345dcdb1674SJordan Crouse if (drm_core_check_feature(dev, DRIVER_MODESET)) { 346dcdb1674SJordan Crouse pci_set_drvdata(pdev, dev); 347dcdb1674SJordan Crouse ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL); 348dcdb1674SJordan Crouse if (ret) 349dcdb1674SJordan Crouse goto err_g2; 350dcdb1674SJordan Crouse } 351dcdb1674SJordan Crouse 352dcdb1674SJordan Crouse if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY))) 353dcdb1674SJordan Crouse goto err_g3; 354dcdb1674SJordan Crouse 355dcdb1674SJordan Crouse if (dev->driver->load) { 356dcdb1674SJordan Crouse ret = dev->driver->load(dev, ent->driver_data); 357dcdb1674SJordan Crouse if (ret) 358dcdb1674SJordan Crouse goto err_g4; 359dcdb1674SJordan Crouse } 360dcdb1674SJordan Crouse 361dcdb1674SJordan Crouse /* setup the grouping for the legacy output */ 362dcdb1674SJordan Crouse if (drm_core_check_feature(dev, DRIVER_MODESET)) { 363dcdb1674SJordan Crouse ret = drm_mode_group_init_legacy_group(dev, 364dcdb1674SJordan Crouse &dev->primary->mode_group); 365dcdb1674SJordan Crouse if (ret) 366dcdb1674SJordan Crouse goto err_g4; 367dcdb1674SJordan Crouse } 368dcdb1674SJordan Crouse 369dcdb1674SJordan Crouse list_add_tail(&dev->driver_item, &driver->device_list); 370dcdb1674SJordan Crouse 371dcdb1674SJordan Crouse DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 372dcdb1674SJordan Crouse driver->name, driver->major, driver->minor, driver->patchlevel, 373dcdb1674SJordan Crouse driver->date, pci_name(pdev), dev->primary->index); 374dcdb1674SJordan Crouse 375b64c115eSDave Airlie mutex_unlock(&drm_global_mutex); 376dcdb1674SJordan Crouse return 0; 377dcdb1674SJordan Crouse 378dcdb1674SJordan Crouse err_g4: 379dcdb1674SJordan Crouse drm_put_minor(&dev->primary); 380dcdb1674SJordan Crouse err_g3: 381dcdb1674SJordan Crouse if (drm_core_check_feature(dev, DRIVER_MODESET)) 382dcdb1674SJordan Crouse drm_put_minor(&dev->control); 383dcdb1674SJordan Crouse err_g2: 384dcdb1674SJordan Crouse pci_disable_device(pdev); 385dcdb1674SJordan Crouse err_g1: 386dcdb1674SJordan Crouse kfree(dev); 387b64c115eSDave Airlie mutex_unlock(&drm_global_mutex); 388dcdb1674SJordan Crouse return ret; 389dcdb1674SJordan Crouse } 390dcdb1674SJordan Crouse EXPORT_SYMBOL(drm_get_pci_dev); 391dcdb1674SJordan Crouse 392dcdb1674SJordan Crouse /** 3938410ea3bSDave Airlie * PCI device initialization. Called direct from modules at load time. 394dcdb1674SJordan Crouse * 395dcdb1674SJordan Crouse * \return zero on success or a negative number on failure. 396dcdb1674SJordan Crouse * 397dcdb1674SJordan Crouse * Initializes a drm_device structures,registering the 398dcdb1674SJordan Crouse * stubs and initializing the AGP device. 399dcdb1674SJordan Crouse * 400dcdb1674SJordan Crouse * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and 401dcdb1674SJordan Crouse * after the initialization for driver customization. 402dcdb1674SJordan Crouse */ 4038410ea3bSDave Airlie int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 404dcdb1674SJordan Crouse { 405dcdb1674SJordan Crouse struct pci_dev *pdev = NULL; 406dcdb1674SJordan Crouse const struct pci_device_id *pid; 407dcdb1674SJordan Crouse int i; 408dcdb1674SJordan Crouse 4098410ea3bSDave Airlie DRM_DEBUG("\n"); 4108410ea3bSDave Airlie 4118410ea3bSDave Airlie INIT_LIST_HEAD(&driver->device_list); 4128410ea3bSDave Airlie driver->kdriver.pci = pdriver; 4138410ea3bSDave Airlie driver->bus = &drm_pci_bus; 4148410ea3bSDave Airlie 415dcdb1674SJordan Crouse if (driver->driver_features & DRIVER_MODESET) 4168410ea3bSDave Airlie return pci_register_driver(pdriver); 417dcdb1674SJordan Crouse 418dcdb1674SJordan Crouse /* If not using KMS, fall back to stealth mode manual scanning. */ 4198410ea3bSDave Airlie for (i = 0; pdriver->id_table[i].vendor != 0; i++) { 4208410ea3bSDave Airlie pid = &pdriver->id_table[i]; 421dcdb1674SJordan Crouse 422dcdb1674SJordan Crouse /* Loop around setting up a DRM device for each PCI device 423dcdb1674SJordan Crouse * matching our ID and device class. If we had the internal 424dcdb1674SJordan Crouse * function that pci_get_subsys and pci_get_class used, we'd 425dcdb1674SJordan Crouse * be able to just pass pid in instead of doing a two-stage 426dcdb1674SJordan Crouse * thing. 427dcdb1674SJordan Crouse */ 428dcdb1674SJordan Crouse pdev = NULL; 429dcdb1674SJordan Crouse while ((pdev = 430dcdb1674SJordan Crouse pci_get_subsys(pid->vendor, pid->device, pid->subvendor, 431dcdb1674SJordan Crouse pid->subdevice, pdev)) != NULL) { 432dcdb1674SJordan Crouse if ((pdev->class & pid->class_mask) != pid->class) 433dcdb1674SJordan Crouse continue; 434dcdb1674SJordan Crouse 435dcdb1674SJordan Crouse /* stealth mode requires a manual probe */ 436dcdb1674SJordan Crouse pci_dev_get(pdev); 437dcdb1674SJordan Crouse drm_get_pci_dev(pdev, pid, driver); 438dcdb1674SJordan Crouse } 439dcdb1674SJordan Crouse } 440dcdb1674SJordan Crouse return 0; 441dcdb1674SJordan Crouse } 442dcdb1674SJordan Crouse 443dcdb1674SJordan Crouse #else 444dcdb1674SJordan Crouse 4458410ea3bSDave Airlie int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) 446dcdb1674SJordan Crouse { 447dcdb1674SJordan Crouse return -1; 448dcdb1674SJordan Crouse } 449dcdb1674SJordan Crouse 450dcdb1674SJordan Crouse #endif 4518410ea3bSDave Airlie 4528410ea3bSDave Airlie EXPORT_SYMBOL(drm_pci_init); 4538410ea3bSDave Airlie 454c0e09200SDave Airlie /*@}*/ 4558410ea3bSDave Airlie void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) 4568410ea3bSDave Airlie { 4578410ea3bSDave Airlie struct drm_device *dev, *tmp; 4588410ea3bSDave Airlie DRM_DEBUG("\n"); 4598410ea3bSDave Airlie 4608410ea3bSDave Airlie if (driver->driver_features & DRIVER_MODESET) { 4618410ea3bSDave Airlie pci_unregister_driver(pdriver); 4628410ea3bSDave Airlie } else { 4638410ea3bSDave Airlie list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item) 4648410ea3bSDave Airlie drm_put_dev(dev); 4658410ea3bSDave Airlie } 4668410ea3bSDave Airlie DRM_INFO("Module unloaded\n"); 4678410ea3bSDave Airlie } 4688410ea3bSDave Airlie EXPORT_SYMBOL(drm_pci_exit); 469