Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Jan Engelhardt | 96de0e2 | 2007-10-19 23:21:04 +0200 | [diff] [blame] | 2 | * Copyright 2003 José Fonseca. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Copyright 2003 Leif Delgass. |
| 4 | * All Rights Reserved. |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 7 | * copy of this software and associated documentation files (the "Software"), |
| 8 | * to deal in the Software without restriction, including without limitation |
| 9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 10 | * and/or sell copies of the Software, and to permit persons to whom the |
| 11 | * Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice (including the next |
| 14 | * paragraph) shall be included in all copies or substantial portions of the |
| 15 | * Software. |
| 16 | * |
| 17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 20 | * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| 21 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| 22 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 23 | */ |
| 24 | |
Dave Airlie | 195b3a2 | 2006-04-05 18:12:18 +1000 | [diff] [blame] | 25 | #include <linux/dma-mapping.h> |
Paul Gortmaker | 2d1a8a4 | 2011-08-30 18:16:33 -0400 | [diff] [blame] | 26 | #include <linux/export.h> |
Sam Ravnborg | 0500c04 | 2019-05-26 19:35:35 +0200 | [diff] [blame] | 27 | #include <linux/pci.h> |
| 28 | #include <linux/slab.h> |
| 29 | |
| 30 | #include <drm/drm.h> |
| 31 | #include <drm/drm_agpsupport.h> |
| 32 | #include <drm/drm_drv.h> |
Sam Ravnborg | 0500c04 | 2019-05-26 19:35:35 +0200 | [diff] [blame] | 33 | #include <drm/drm_print.h> |
| 34 | |
Ville Syrjälä | 43fc884 | 2015-03-13 14:51:25 +0200 | [diff] [blame] | 35 | #include "drm_internal.h" |
Daniel Vetter | ba8286f | 2014-09-11 07:43:25 +0200 | [diff] [blame] | 36 | #include "drm_legacy.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
Daniel Vetter | 3377533 | 2020-04-03 13:06:09 +0200 | [diff] [blame] | 38 | #ifdef CONFIG_DRM_LEGACY |
| 39 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | /** |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 41 | * drm_pci_alloc - Allocate a PCI consistent memory block, for DMA. |
| 42 | * @dev: DRM device |
| 43 | * @size: size of block to allocate |
| 44 | * @align: alignment of block |
| 45 | * |
Daniel Vetter | 23ef59e | 2017-03-08 15:12:37 +0100 | [diff] [blame] | 46 | * FIXME: This is a needless abstraction of the Linux dma-api and should be |
| 47 | * removed. |
| 48 | * |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 49 | * Return: A handle to the allocated memory block on success or NULL on |
| 50 | * failure. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | */ |
Zhenyu Wang | e6be8d9 | 2010-01-05 11:25:05 +0800 | [diff] [blame] | 52 | drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | { |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 54 | drm_dma_handle_t *dmah; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | |
| 56 | /* pci_alloc_consistent only guarantees alignment to the smallest |
| 57 | * PAGE_SIZE order which is greater than or equal to the requested size. |
| 58 | * Return NULL here for now to make sure nobody tries for larger alignment |
| 59 | */ |
| 60 | if (align > size) |
| 61 | return NULL; |
| 62 | |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 63 | dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL); |
| 64 | if (!dmah) |
| 65 | return NULL; |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 66 | |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 67 | dmah->size = size; |
Luis Chamberlain | 750afb0 | 2019-01-04 09:23:09 +0100 | [diff] [blame] | 68 | dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, |
| 69 | &dmah->busaddr, |
Chris Wilson | ea36ec8 | 2020-02-02 17:16:31 +0000 | [diff] [blame] | 70 | GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 72 | if (dmah->vaddr == NULL) { |
| 73 | kfree(dmah); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | return NULL; |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 75 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 77 | return dmah; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | } |
| 79 | EXPORT_SYMBOL(drm_pci_alloc); |
| 80 | |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 81 | /** |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 82 | * drm_pci_free - Free a PCI consistent memory block |
| 83 | * @dev: DRM device |
| 84 | * @dmah: handle to memory block |
Daniel Vetter | 23ef59e | 2017-03-08 15:12:37 +0100 | [diff] [blame] | 85 | * |
| 86 | * FIXME: This is a needless abstraction of the Linux dma-api and should be |
| 87 | * removed. |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 88 | */ |
Dave Airlie | 84b1fd1 | 2007-07-11 15:53:27 +1000 | [diff] [blame] | 89 | void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 90 | { |
Chris Wilson | 8e4ff9b | 2020-02-02 17:16:32 +0000 | [diff] [blame] | 91 | dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, |
| 92 | dmah->busaddr); |
Dave Airlie | 9c8da5e | 2005-07-10 15:38:56 +1000 | [diff] [blame] | 93 | kfree(dmah); |
| 94 | } |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 95 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | EXPORT_SYMBOL(drm_pci_free); |
Daniel Vetter | 3377533 | 2020-04-03 13:06:09 +0200 | [diff] [blame] | 97 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 99 | static int drm_get_pci_domain(struct drm_device *dev) |
| 100 | { |
| 101 | #ifndef __alpha__ |
| 102 | /* For historical reasons, drm_get_pci_domain() is busticated |
| 103 | * on most archs and has to remain so for userspace interface |
| 104 | * < 1.4, except on alpha which was right from the beginning |
| 105 | */ |
| 106 | if (dev->if_version < 0x10004) |
| 107 | return 0; |
| 108 | #endif /* __alpha__ */ |
| 109 | |
| 110 | return pci_domain_nr(dev->pdev->bus); |
| 111 | } |
| 112 | |
David Herrmann | 915b4d1 | 2014-08-29 12:12:43 +0200 | [diff] [blame] | 113 | int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 114 | { |
David Herrmann | d0a3916 | 2014-08-29 12:12:41 +0200 | [diff] [blame] | 115 | master->unique = kasprintf(GFP_KERNEL, "pci:%04x:%02x:%02x.%d", |
| 116 | drm_get_pci_domain(dev), |
| 117 | dev->pdev->bus->number, |
| 118 | PCI_SLOT(dev->pdev->devfn), |
| 119 | PCI_FUNC(dev->pdev->devfn)); |
| 120 | if (!master->unique) |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 121 | return -ENOMEM; |
| 122 | |
David Herrmann | d0a3916 | 2014-08-29 12:12:41 +0200 | [diff] [blame] | 123 | master->unique_len = strlen(master->unique); |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 124 | return 0; |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 125 | } |
| 126 | |
Wolfram Sang | 45e97ab | 2011-06-15 11:26:47 +0200 | [diff] [blame] | 127 | static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 128 | { |
| 129 | if ((p->busnum >> 8) != drm_get_pci_domain(dev) || |
| 130 | (p->busnum & 0xff) != dev->pdev->bus->number || |
| 131 | p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) |
| 132 | return -EINVAL; |
| 133 | |
| 134 | p->irq = dev->pdev->irq; |
| 135 | |
| 136 | DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, |
| 137 | p->irq); |
| 138 | return 0; |
| 139 | } |
| 140 | |
Daniel Vetter | eaaf8f0 | 2013-08-28 15:19:23 +0200 | [diff] [blame] | 141 | /** |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 142 | * drm_irq_by_busid - Get interrupt from bus ID |
| 143 | * @dev: DRM device |
| 144 | * @data: IOCTL parameter pointing to a drm_irq_busid structure |
| 145 | * @file_priv: DRM file private. |
Daniel Vetter | eaaf8f0 | 2013-08-28 15:19:23 +0200 | [diff] [blame] | 146 | * |
| 147 | * Finds the PCI device with the specified bus id and gets its IRQ number. |
| 148 | * This IOCTL is deprecated, and will now return EINVAL for any busid not equal |
| 149 | * to that of the device that this DRM instance attached to. |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 150 | * |
| 151 | * Return: 0 on success or a negative error code on failure. |
Daniel Vetter | eaaf8f0 | 2013-08-28 15:19:23 +0200 | [diff] [blame] | 152 | */ |
| 153 | int drm_irq_by_busid(struct drm_device *dev, void *data, |
| 154 | struct drm_file *file_priv) |
| 155 | { |
| 156 | struct drm_irq_busid *p = data; |
| 157 | |
Daniel Vetter | fa53864 | 2016-08-03 21:11:10 +0200 | [diff] [blame] | 158 | if (!drm_core_check_feature(dev, DRIVER_LEGACY)) |
Chris Wilson | 69fdf42 | 2018-09-13 20:20:50 +0100 | [diff] [blame] | 159 | return -EOPNOTSUPP; |
Daniel Vetter | eaaf8f0 | 2013-08-28 15:19:23 +0200 | [diff] [blame] | 160 | |
| 161 | /* UMS was only ever support on PCI devices. */ |
| 162 | if (WARN_ON(!dev->pdev)) |
| 163 | return -EINVAL; |
| 164 | |
| 165 | if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) |
Chris Wilson | 69fdf42 | 2018-09-13 20:20:50 +0100 | [diff] [blame] | 166 | return -EOPNOTSUPP; |
Daniel Vetter | eaaf8f0 | 2013-08-28 15:19:23 +0200 | [diff] [blame] | 167 | |
| 168 | return drm_pci_irq_by_busid(dev, p); |
| 169 | } |
| 170 | |
Chris Wilson | ee21ec7 | 2020-03-07 09:37:02 +0000 | [diff] [blame] | 171 | void drm_pci_agp_destroy(struct drm_device *dev) |
| 172 | { |
| 173 | if (dev->agp) { |
| 174 | arch_phys_wc_del(dev->agp->agp_mtrr); |
| 175 | drm_legacy_agp_clear(dev); |
| 176 | kfree(dev->agp); |
| 177 | dev->agp = NULL; |
| 178 | } |
| 179 | } |
| 180 | |
| 181 | #ifdef CONFIG_DRM_LEGACY |
| 182 | |
Daniel Vetter | 8da79cc | 2013-12-11 11:34:34 +0100 | [diff] [blame] | 183 | static void drm_pci_agp_init(struct drm_device *dev) |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 184 | { |
Daniel Vetter | d990675 | 2013-12-11 11:34:35 +0100 | [diff] [blame] | 185 | if (drm_core_check_feature(dev, DRIVER_USE_AGP)) { |
Daniel Vetter | 2ce0264 | 2017-01-25 07:26:52 +0100 | [diff] [blame] | 186 | if (pci_find_capability(dev->pdev, PCI_CAP_ID_AGP)) |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 187 | dev->agp = drm_agp_init(dev); |
Daniel Vetter | 2818564 | 2013-08-08 15:41:27 +0200 | [diff] [blame] | 188 | if (dev->agp) { |
| 189 | dev->agp->agp_mtrr = arch_phys_wc_add( |
| 190 | dev->agp->agp_info.aper_base, |
| 191 | dev->agp->agp_info.aper_size * |
| 192 | 1024 * 1024); |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 193 | } |
| 194 | } |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 195 | } |
| 196 | |
Daniel Vetter | c393fba | 2020-02-25 17:58:35 +0100 | [diff] [blame] | 197 | static int drm_get_pci_dev(struct pci_dev *pdev, |
| 198 | const struct pci_device_id *ent, |
| 199 | struct drm_driver *driver) |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 200 | { |
| 201 | struct drm_device *dev; |
| 202 | int ret; |
| 203 | |
| 204 | DRM_DEBUG("\n"); |
| 205 | |
David Herrmann | 1bb7253 | 2013-10-02 11:23:34 +0200 | [diff] [blame] | 206 | dev = drm_dev_alloc(driver, &pdev->dev); |
Tom Gundersen | 0f288605 | 2016-09-21 16:59:19 +0200 | [diff] [blame] | 207 | if (IS_ERR(dev)) |
| 208 | return PTR_ERR(dev); |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 209 | |
| 210 | ret = pci_enable_device(pdev); |
| 211 | if (ret) |
David Herrmann | c22f0ac | 2013-10-02 11:23:35 +0200 | [diff] [blame] | 212 | goto err_free; |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 213 | |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 214 | dev->pdev = pdev; |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 215 | #ifdef __alpha__ |
| 216 | dev->hose = pdev->sysdata; |
| 217 | #endif |
| 218 | |
David Herrmann | c22f0ac | 2013-10-02 11:23:35 +0200 | [diff] [blame] | 219 | if (drm_core_check_feature(dev, DRIVER_MODESET)) |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 220 | pci_set_drvdata(pdev, dev); |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 221 | |
Daniel Vetter | 2c695fa | 2013-12-11 11:34:36 +0100 | [diff] [blame] | 222 | drm_pci_agp_init(dev); |
Daniel Vetter | 2c695fa | 2013-12-11 11:34:36 +0100 | [diff] [blame] | 223 | |
David Herrmann | c22f0ac | 2013-10-02 11:23:35 +0200 | [diff] [blame] | 224 | ret = drm_dev_register(dev, ent->driver_data); |
| 225 | if (ret) |
Daniel Vetter | 2c695fa | 2013-12-11 11:34:36 +0100 | [diff] [blame] | 226 | goto err_agp; |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 227 | |
Daniel Vetter | b3f2333 | 2013-12-11 11:34:31 +0100 | [diff] [blame] | 228 | /* No locking needed since shadow-attach is single-threaded since it may |
| 229 | * only be called from the per-driver module init hook. */ |
Daniel Vetter | fa53864 | 2016-08-03 21:11:10 +0200 | [diff] [blame] | 230 | if (drm_core_check_feature(dev, DRIVER_LEGACY)) |
Daniel Vetter | b3f2333 | 2013-12-11 11:34:31 +0100 | [diff] [blame] | 231 | list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list); |
| 232 | |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 233 | return 0; |
| 234 | |
Daniel Vetter | 2c695fa | 2013-12-11 11:34:36 +0100 | [diff] [blame] | 235 | err_agp: |
Daniel Vetter | 2c695fa | 2013-12-11 11:34:36 +0100 | [diff] [blame] | 236 | drm_pci_agp_destroy(dev); |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 237 | pci_disable_device(pdev); |
David Herrmann | c22f0ac | 2013-10-02 11:23:35 +0200 | [diff] [blame] | 238 | err_free: |
Aishwarya Pant | ffeeeed | 2017-09-26 22:34:00 +0530 | [diff] [blame] | 239 | drm_dev_put(dev); |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 240 | return ret; |
| 241 | } |
Thomas Zimmermann | 1be9d5f | 2019-12-03 11:03:56 +0100 | [diff] [blame] | 242 | |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 243 | /** |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 244 | * drm_legacy_pci_init - shadow-attach a legacy DRM PCI driver |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 245 | * @driver: DRM device driver |
| 246 | * @pdriver: PCI device driver |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 247 | * |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 248 | * This is only used by legacy dri1 drivers and deprecated. |
Daniel Vetter | 6e3f797 | 2015-09-28 21:46:35 +0200 | [diff] [blame] | 249 | * |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 250 | * Return: 0 on success or a negative error code on failure. |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 251 | */ |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 252 | int drm_legacy_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 253 | { |
| 254 | struct pci_dev *pdev = NULL; |
| 255 | const struct pci_device_id *pid; |
| 256 | int i; |
| 257 | |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 258 | DRM_DEBUG("\n"); |
| 259 | |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 260 | if (WARN_ON(!(driver->driver_features & DRIVER_LEGACY))) |
| 261 | return -EINVAL; |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 262 | |
| 263 | /* If not using KMS, fall back to stealth mode manual scanning. */ |
Daniel Vetter | b3f2333 | 2013-12-11 11:34:31 +0100 | [diff] [blame] | 264 | INIT_LIST_HEAD(&driver->legacy_dev_list); |
Dave Airlie | 8410ea3 | 2010-12-15 03:16:38 +1000 | [diff] [blame] | 265 | for (i = 0; pdriver->id_table[i].vendor != 0; i++) { |
| 266 | pid = &pdriver->id_table[i]; |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 267 | |
| 268 | /* Loop around setting up a DRM device for each PCI device |
| 269 | * matching our ID and device class. If we had the internal |
| 270 | * function that pci_get_subsys and pci_get_class used, we'd |
| 271 | * be able to just pass pid in instead of doing a two-stage |
| 272 | * thing. |
| 273 | */ |
| 274 | pdev = NULL; |
| 275 | while ((pdev = |
| 276 | pci_get_subsys(pid->vendor, pid->device, pid->subvendor, |
| 277 | pid->subdevice, pdev)) != NULL) { |
| 278 | if ((pdev->class & pid->class_mask) != pid->class) |
| 279 | continue; |
| 280 | |
| 281 | /* stealth mode requires a manual probe */ |
| 282 | pci_dev_get(pdev); |
| 283 | drm_get_pci_dev(pdev, pid, driver); |
| 284 | } |
| 285 | } |
| 286 | return 0; |
| 287 | } |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 288 | EXPORT_SYMBOL(drm_legacy_pci_init); |
Jordan Crouse | dcdb167 | 2010-05-27 13:40:25 -0600 | [diff] [blame] | 289 | |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 290 | /** |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 291 | * drm_legacy_pci_exit - unregister shadow-attach legacy DRM driver |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 292 | * @driver: DRM device driver |
| 293 | * @pdriver: PCI device driver |
| 294 | * |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 295 | * Unregister a DRM driver shadow-attached through drm_legacy_pci_init(). This |
| 296 | * is deprecated and only used by dri1 drivers. |
Thierry Reding | c6a1af8a | 2014-05-19 13:39:07 +0200 | [diff] [blame] | 297 | */ |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 298 | void drm_legacy_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) |
Bjorn Helgaas | 93711d8 | 2013-02-08 15:27:01 -0700 | [diff] [blame] | 299 | { |
| 300 | struct drm_device *dev, *tmp; |
| 301 | DRM_DEBUG("\n"); |
| 302 | |
Daniel Vetter | fa53864 | 2016-08-03 21:11:10 +0200 | [diff] [blame] | 303 | if (!(driver->driver_features & DRIVER_LEGACY)) { |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 304 | WARN_ON(1); |
Bjorn Helgaas | 93711d8 | 2013-02-08 15:27:01 -0700 | [diff] [blame] | 305 | } else { |
Daniel Vetter | b3f2333 | 2013-12-11 11:34:31 +0100 | [diff] [blame] | 306 | list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list, |
| 307 | legacy_dev_list) { |
Daniel Vetter | b3f2333 | 2013-12-11 11:34:31 +0100 | [diff] [blame] | 308 | list_del(&dev->legacy_dev_list); |
Daniel Vetter | c94adc4 | 2014-01-30 17:58:38 +0100 | [diff] [blame] | 309 | drm_put_dev(dev); |
Daniel Vetter | b3f2333 | 2013-12-11 11:34:31 +0100 | [diff] [blame] | 310 | } |
Bjorn Helgaas | 93711d8 | 2013-02-08 15:27:01 -0700 | [diff] [blame] | 311 | } |
| 312 | DRM_INFO("Module unloaded\n"); |
| 313 | } |
Daniel Vetter | 10631d7 | 2017-05-24 16:51:40 +0200 | [diff] [blame] | 314 | EXPORT_SYMBOL(drm_legacy_pci_exit); |
Thomas Zimmermann | 1be9d5f | 2019-12-03 11:03:56 +0100 | [diff] [blame] | 315 | |
| 316 | #endif |