Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
96de0e25 | 2 | * Copyright 2003 José Fonseca. |
1da177e4 LT |
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 | ||
25 | #include <linux/pci.h> | |
5a0e3ad6 | 26 | #include <linux/slab.h> |
195b3a2d | 27 | #include <linux/dma-mapping.h> |
2d1a8a48 | 28 | #include <linux/export.h> |
760285e7 | 29 | #include <drm/drmP.h> |
43fc884e | 30 | #include "drm_internal.h" |
ba8286fa | 31 | #include "drm_legacy.h" |
1da177e4 | 32 | |
1da177e4 | 33 | /** |
c6a1af8a TR |
34 | * drm_pci_alloc - Allocate a PCI consistent memory block, for DMA. |
35 | * @dev: DRM device | |
36 | * @size: size of block to allocate | |
37 | * @align: alignment of block | |
38 | * | |
39 | * Return: A handle to the allocated memory block on success or NULL on | |
40 | * failure. | |
1da177e4 | 41 | */ |
e6be8d9d | 42 | drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align) |
1da177e4 | 43 | { |
9c8da5eb | 44 | drm_dma_handle_t *dmah; |
ddf19b97 DA |
45 | unsigned long addr; |
46 | size_t sz; | |
1da177e4 LT |
47 | |
48 | /* pci_alloc_consistent only guarantees alignment to the smallest | |
49 | * PAGE_SIZE order which is greater than or equal to the requested size. | |
50 | * Return NULL here for now to make sure nobody tries for larger alignment | |
51 | */ | |
52 | if (align > size) | |
53 | return NULL; | |
54 | ||
9c8da5eb DA |
55 | dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL); |
56 | if (!dmah) | |
57 | return NULL; | |
b5e89ed5 | 58 | |
9c8da5eb | 59 | dmah->size = size; |
ddf19b97 | 60 | dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP); |
1da177e4 | 61 | |
9c8da5eb DA |
62 | if (dmah->vaddr == NULL) { |
63 | kfree(dmah); | |
1da177e4 | 64 | return NULL; |
9c8da5eb | 65 | } |
1da177e4 | 66 | |
9c8da5eb | 67 | memset(dmah->vaddr, 0, size); |
1da177e4 | 68 | |
ddf19b97 DA |
69 | /* XXX - Is virt_to_page() legal for consistent mem? */ |
70 | /* Reserve */ | |
71 | for (addr = (unsigned long)dmah->vaddr, sz = size; | |
72 | sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { | |
e1e78533 | 73 | SetPageReserved(virt_to_page((void *)addr)); |
ddf19b97 DA |
74 | } |
75 | ||
9c8da5eb | 76 | return dmah; |
1da177e4 | 77 | } |
b5e89ed5 | 78 | |
1da177e4 LT |
79 | EXPORT_SYMBOL(drm_pci_alloc); |
80 | ||
c6a1af8a TR |
81 | /* |
82 | * Free a PCI consistent memory block without freeing its descriptor. | |
9c8da5eb DA |
83 | * |
84 | * This function is for internal use in the Linux-specific DRM core code. | |
1da177e4 | 85 | */ |
1c96e84e | 86 | void __drm_legacy_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) |
1da177e4 | 87 | { |
ddf19b97 DA |
88 | unsigned long addr; |
89 | size_t sz; | |
1da177e4 | 90 | |
9a298b2a | 91 | if (dmah->vaddr) { |
ddf19b97 DA |
92 | /* XXX - Is virt_to_page() legal for consistent mem? */ |
93 | /* Unreserve */ | |
94 | for (addr = (unsigned long)dmah->vaddr, sz = dmah->size; | |
95 | sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { | |
e1e78533 | 96 | ClearPageReserved(virt_to_page((void *)addr)); |
ddf19b97 DA |
97 | } |
98 | dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, | |
99 | dmah->busaddr); | |
1da177e4 | 100 | } |
1da177e4 | 101 | } |
9c8da5eb DA |
102 | |
103 | /** | |
c6a1af8a TR |
104 | * drm_pci_free - Free a PCI consistent memory block |
105 | * @dev: DRM device | |
106 | * @dmah: handle to memory block | |
9c8da5eb | 107 | */ |
84b1fd10 | 108 | void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) |
9c8da5eb | 109 | { |
1c96e84e | 110 | __drm_legacy_pci_free(dev, dmah); |
9c8da5eb DA |
111 | kfree(dmah); |
112 | } | |
b5e89ed5 | 113 | |
1da177e4 LT |
114 | EXPORT_SYMBOL(drm_pci_free); |
115 | ||
dcdb1674 | 116 | #ifdef CONFIG_PCI |
8410ea3b DA |
117 | |
118 | static int drm_get_pci_domain(struct drm_device *dev) | |
119 | { | |
120 | #ifndef __alpha__ | |
121 | /* For historical reasons, drm_get_pci_domain() is busticated | |
122 | * on most archs and has to remain so for userspace interface | |
123 | * < 1.4, except on alpha which was right from the beginning | |
124 | */ | |
125 | if (dev->if_version < 0x10004) | |
126 | return 0; | |
127 | #endif /* __alpha__ */ | |
128 | ||
129 | return pci_domain_nr(dev->pdev->bus); | |
130 | } | |
131 | ||
915b4d11 | 132 | int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) |
8410ea3b | 133 | { |
d0a39164 DH |
134 | master->unique = kasprintf(GFP_KERNEL, "pci:%04x:%02x:%02x.%d", |
135 | drm_get_pci_domain(dev), | |
136 | dev->pdev->bus->number, | |
137 | PCI_SLOT(dev->pdev->devfn), | |
138 | PCI_FUNC(dev->pdev->devfn)); | |
139 | if (!master->unique) | |
8410ea3b DA |
140 | return -ENOMEM; |
141 | ||
d0a39164 | 142 | master->unique_len = strlen(master->unique); |
8410ea3b | 143 | return 0; |
8410ea3b | 144 | } |
915b4d11 | 145 | EXPORT_SYMBOL(drm_pci_set_busid); |
8410ea3b | 146 | |
53bf2a2b DV |
147 | int drm_pci_set_unique(struct drm_device *dev, |
148 | struct drm_master *master, | |
149 | struct drm_unique *u) | |
8410ea3b DA |
150 | { |
151 | int domain, bus, slot, func, ret; | |
8410ea3b DA |
152 | |
153 | master->unique_len = u->unique_len; | |
1e444be0 | 154 | master->unique = kmalloc(master->unique_len + 1, GFP_KERNEL); |
8410ea3b DA |
155 | if (!master->unique) { |
156 | ret = -ENOMEM; | |
157 | goto err; | |
158 | } | |
159 | ||
160 | if (copy_from_user(master->unique, u->unique, master->unique_len)) { | |
161 | ret = -EFAULT; | |
162 | goto err; | |
163 | } | |
164 | ||
165 | master->unique[master->unique_len] = '\0'; | |
166 | ||
8410ea3b DA |
167 | /* Return error if the busid submitted doesn't match the device's actual |
168 | * busid. | |
169 | */ | |
170 | ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func); | |
171 | if (ret != 3) { | |
172 | ret = -EINVAL; | |
173 | goto err; | |
174 | } | |
175 | ||
176 | domain = bus >> 8; | |
177 | bus &= 0xff; | |
178 | ||
179 | if ((domain != drm_get_pci_domain(dev)) || | |
180 | (bus != dev->pdev->bus->number) || | |
181 | (slot != PCI_SLOT(dev->pdev->devfn)) || | |
182 | (func != PCI_FUNC(dev->pdev->devfn))) { | |
183 | ret = -EINVAL; | |
184 | goto err; | |
185 | } | |
186 | return 0; | |
187 | err: | |
188 | return ret; | |
189 | } | |
190 | ||
45e97ab6 | 191 | static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) |
8410ea3b DA |
192 | { |
193 | if ((p->busnum >> 8) != drm_get_pci_domain(dev) || | |
194 | (p->busnum & 0xff) != dev->pdev->bus->number || | |
195 | p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) | |
196 | return -EINVAL; | |
197 | ||
198 | p->irq = dev->pdev->irq; | |
199 | ||
200 | DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, | |
201 | p->irq); | |
202 | return 0; | |
203 | } | |
204 | ||
eaaf8f0f | 205 | /** |
c6a1af8a TR |
206 | * drm_irq_by_busid - Get interrupt from bus ID |
207 | * @dev: DRM device | |
208 | * @data: IOCTL parameter pointing to a drm_irq_busid structure | |
209 | * @file_priv: DRM file private. | |
eaaf8f0f DV |
210 | * |
211 | * Finds the PCI device with the specified bus id and gets its IRQ number. | |
212 | * This IOCTL is deprecated, and will now return EINVAL for any busid not equal | |
213 | * to that of the device that this DRM instance attached to. | |
c6a1af8a TR |
214 | * |
215 | * Return: 0 on success or a negative error code on failure. | |
eaaf8f0f DV |
216 | */ |
217 | int drm_irq_by_busid(struct drm_device *dev, void *data, | |
218 | struct drm_file *file_priv) | |
219 | { | |
220 | struct drm_irq_busid *p = data; | |
221 | ||
222 | if (drm_core_check_feature(dev, DRIVER_MODESET)) | |
223 | return -EINVAL; | |
224 | ||
225 | /* UMS was only ever support on PCI devices. */ | |
226 | if (WARN_ON(!dev->pdev)) | |
227 | return -EINVAL; | |
228 | ||
229 | if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) | |
230 | return -EINVAL; | |
231 | ||
232 | return drm_pci_irq_by_busid(dev, p); | |
233 | } | |
234 | ||
8da79ccd | 235 | static void drm_pci_agp_init(struct drm_device *dev) |
8410ea3b | 236 | { |
d9906753 | 237 | if (drm_core_check_feature(dev, DRIVER_USE_AGP)) { |
8410ea3b DA |
238 | if (drm_pci_device_is_agp(dev)) |
239 | dev->agp = drm_agp_init(dev); | |
28185647 DV |
240 | if (dev->agp) { |
241 | dev->agp->agp_mtrr = arch_phys_wc_add( | |
242 | dev->agp->agp_info.aper_base, | |
243 | dev->agp->agp_info.aper_size * | |
244 | 1024 * 1024); | |
8410ea3b DA |
245 | } |
246 | } | |
8410ea3b DA |
247 | } |
248 | ||
4efafebe | 249 | void drm_pci_agp_destroy(struct drm_device *dev) |
28ec711c | 250 | { |
d9906753 | 251 | if (dev->agp) { |
28185647 | 252 | arch_phys_wc_del(dev->agp->agp_mtrr); |
28ec711c | 253 | drm_agp_clear(dev); |
d6e4b28b | 254 | kfree(dev->agp); |
28ec711c DH |
255 | dev->agp = NULL; |
256 | } | |
257 | } | |
258 | ||
dcdb1674 | 259 | /** |
c6a1af8a TR |
260 | * drm_get_pci_dev - Register a PCI device with the DRM subsystem |
261 | * @pdev: PCI device | |
262 | * @ent: entry from the PCI ID table that matches @pdev | |
263 | * @driver: DRM device driver | |
dcdb1674 JC |
264 | * |
265 | * Attempt to gets inter module "drm" information. If we are first | |
266 | * then register the character device and inter module information. | |
267 | * Try and register, if we fail to register, backout previous work. | |
c6a1af8a | 268 | * |
6e3f797c DV |
269 | * NOTE: This function is deprecated, please use drm_dev_alloc() and |
270 | * drm_dev_register() instead and remove your ->load() callback. | |
271 | * | |
c6a1af8a | 272 | * Return: 0 on success or a negative error code on failure. |
dcdb1674 JC |
273 | */ |
274 | int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, | |
275 | struct drm_driver *driver) | |
276 | { | |
277 | struct drm_device *dev; | |
278 | int ret; | |
279 | ||
280 | DRM_DEBUG("\n"); | |
281 | ||
1bb72532 | 282 | dev = drm_dev_alloc(driver, &pdev->dev); |
dcdb1674 JC |
283 | if (!dev) |
284 | return -ENOMEM; | |
285 | ||
286 | ret = pci_enable_device(pdev); | |
287 | if (ret) | |
c22f0ace | 288 | goto err_free; |
dcdb1674 | 289 | |
dcdb1674 | 290 | dev->pdev = pdev; |
dcdb1674 JC |
291 | #ifdef __alpha__ |
292 | dev->hose = pdev->sysdata; | |
293 | #endif | |
294 | ||
c22f0ace | 295 | if (drm_core_check_feature(dev, DRIVER_MODESET)) |
dcdb1674 | 296 | pci_set_drvdata(pdev, dev); |
1793126f | 297 | |
2c695fa0 | 298 | drm_pci_agp_init(dev); |
2c695fa0 | 299 | |
c22f0ace DH |
300 | ret = drm_dev_register(dev, ent->driver_data); |
301 | if (ret) | |
2c695fa0 | 302 | goto err_agp; |
dcdb1674 JC |
303 | |
304 | DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", | |
305 | driver->name, driver->major, driver->minor, driver->patchlevel, | |
306 | driver->date, pci_name(pdev), dev->primary->index); | |
307 | ||
b3f2333d DV |
308 | /* No locking needed since shadow-attach is single-threaded since it may |
309 | * only be called from the per-driver module init hook. */ | |
310 | if (!drm_core_check_feature(dev, DRIVER_MODESET)) | |
311 | list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list); | |
312 | ||
dcdb1674 JC |
313 | return 0; |
314 | ||
2c695fa0 | 315 | err_agp: |
2c695fa0 | 316 | drm_pci_agp_destroy(dev); |
dcdb1674 | 317 | pci_disable_device(pdev); |
c22f0ace | 318 | err_free: |
099d1c29 | 319 | drm_dev_unref(dev); |
dcdb1674 JC |
320 | return ret; |
321 | } | |
322 | EXPORT_SYMBOL(drm_get_pci_dev); | |
323 | ||
324 | /** | |
c6a1af8a TR |
325 | * drm_pci_init - Register matching PCI devices with the DRM subsystem |
326 | * @driver: DRM device driver | |
327 | * @pdriver: PCI device driver | |
dcdb1674 | 328 | * |
c6a1af8a TR |
329 | * Initializes a drm_device structures, registering the stubs and initializing |
330 | * the AGP device. | |
dcdb1674 | 331 | * |
6e3f797c DV |
332 | * NOTE: This function is deprecated. Modern modesetting drm drivers should use |
333 | * pci_register_driver() directly, this function only provides shadow-binding | |
334 | * support for old legacy drivers on top of that core pci function. | |
335 | * | |
c6a1af8a | 336 | * Return: 0 on success or a negative error code on failure. |
dcdb1674 | 337 | */ |
8410ea3b | 338 | int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) |
dcdb1674 JC |
339 | { |
340 | struct pci_dev *pdev = NULL; | |
341 | const struct pci_device_id *pid; | |
342 | int i; | |
343 | ||
8410ea3b DA |
344 | DRM_DEBUG("\n"); |
345 | ||
dcdb1674 | 346 | if (driver->driver_features & DRIVER_MODESET) |
8410ea3b | 347 | return pci_register_driver(pdriver); |
dcdb1674 JC |
348 | |
349 | /* If not using KMS, fall back to stealth mode manual scanning. */ | |
b3f2333d | 350 | INIT_LIST_HEAD(&driver->legacy_dev_list); |
8410ea3b DA |
351 | for (i = 0; pdriver->id_table[i].vendor != 0; i++) { |
352 | pid = &pdriver->id_table[i]; | |
dcdb1674 JC |
353 | |
354 | /* Loop around setting up a DRM device for each PCI device | |
355 | * matching our ID and device class. If we had the internal | |
356 | * function that pci_get_subsys and pci_get_class used, we'd | |
357 | * be able to just pass pid in instead of doing a two-stage | |
358 | * thing. | |
359 | */ | |
360 | pdev = NULL; | |
361 | while ((pdev = | |
362 | pci_get_subsys(pid->vendor, pid->device, pid->subvendor, | |
363 | pid->subdevice, pdev)) != NULL) { | |
364 | if ((pdev->class & pid->class_mask) != pid->class) | |
365 | continue; | |
366 | ||
367 | /* stealth mode requires a manual probe */ | |
368 | pci_dev_get(pdev); | |
369 | drm_get_pci_dev(pdev, pid, driver); | |
370 | } | |
371 | } | |
372 | return 0; | |
373 | } | |
374 | ||
f4297784 DA |
375 | int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask) |
376 | { | |
377 | struct pci_dev *root; | |
dd66cc2e | 378 | u32 lnkcap, lnkcap2; |
f4297784 DA |
379 | |
380 | *mask = 0; | |
381 | if (!dev->pdev) | |
382 | return -EINVAL; | |
383 | ||
f4297784 DA |
384 | root = dev->pdev->bus->self; |
385 | ||
f4297784 DA |
386 | /* we've been informed via and serverworks don't make the cut */ |
387 | if (root->vendor == PCI_VENDOR_ID_VIA || | |
388 | root->vendor == PCI_VENDOR_ID_SERVERWORKS) | |
389 | return -EINVAL; | |
390 | ||
dd66cc2e BH |
391 | pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap); |
392 | pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2); | |
f4297784 | 393 | |
dd66cc2e | 394 | if (lnkcap2) { /* PCIe r3.0-compliant */ |
f4297784 DA |
395 | if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB) |
396 | *mask |= DRM_PCIE_SPEED_25; | |
397 | if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB) | |
398 | *mask |= DRM_PCIE_SPEED_50; | |
399 | if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB) | |
400 | *mask |= DRM_PCIE_SPEED_80; | |
dd66cc2e | 401 | } else { /* pre-r3.0 */ |
9fe0423e | 402 | if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB) |
f4297784 | 403 | *mask |= DRM_PCIE_SPEED_25; |
9fe0423e | 404 | if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB) |
f8acf6f4 | 405 | *mask |= (DRM_PCIE_SPEED_25 | DRM_PCIE_SPEED_50); |
f4297784 DA |
406 | } |
407 | ||
408 | DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2); | |
409 | return 0; | |
410 | } | |
411 | EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask); | |
93711d8b | 412 | |
60d8edd4 AD |
413 | int drm_pcie_get_max_link_width(struct drm_device *dev, u32 *mlw) |
414 | { | |
415 | struct pci_dev *root; | |
416 | u32 lnkcap; | |
417 | ||
418 | *mlw = 0; | |
419 | if (!dev->pdev) | |
420 | return -EINVAL; | |
421 | ||
422 | root = dev->pdev->bus->self; | |
423 | ||
424 | pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap); | |
425 | ||
426 | *mlw = (lnkcap & PCI_EXP_LNKCAP_MLW) >> 4; | |
427 | ||
428 | DRM_INFO("probing mlw for device %x:%x = %x\n", root->vendor, root->device, lnkcap); | |
429 | return 0; | |
430 | } | |
431 | EXPORT_SYMBOL(drm_pcie_get_max_link_width); | |
432 | ||
93711d8b BH |
433 | #else |
434 | ||
435 | int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) | |
436 | { | |
437 | return -1; | |
438 | } | |
439 | ||
4efafebe | 440 | void drm_pci_agp_destroy(struct drm_device *dev) {} |
eaaf8f0f DV |
441 | |
442 | int drm_irq_by_busid(struct drm_device *dev, void *data, | |
443 | struct drm_file *file_priv) | |
444 | { | |
445 | return -EINVAL; | |
446 | } | |
53bf2a2b DV |
447 | |
448 | int drm_pci_set_unique(struct drm_device *dev, | |
449 | struct drm_master *master, | |
450 | struct drm_unique *u) | |
451 | { | |
452 | return -EINVAL; | |
453 | } | |
93711d8b BH |
454 | #endif |
455 | ||
456 | EXPORT_SYMBOL(drm_pci_init); | |
457 | ||
c6a1af8a TR |
458 | /** |
459 | * drm_pci_exit - Unregister matching PCI devices from the DRM subsystem | |
460 | * @driver: DRM device driver | |
461 | * @pdriver: PCI device driver | |
462 | * | |
463 | * Unregisters one or more devices matched by a PCI driver from the DRM | |
464 | * subsystem. | |
6e3f797c DV |
465 | * |
466 | * NOTE: This function is deprecated. Modern modesetting drm drivers should use | |
467 | * pci_unregister_driver() directly, this function only provides shadow-binding | |
468 | * support for old legacy drivers on top of that core pci function. | |
c6a1af8a | 469 | */ |
93711d8b BH |
470 | void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) |
471 | { | |
472 | struct drm_device *dev, *tmp; | |
473 | DRM_DEBUG("\n"); | |
474 | ||
475 | if (driver->driver_features & DRIVER_MODESET) { | |
476 | pci_unregister_driver(pdriver); | |
477 | } else { | |
b3f2333d DV |
478 | list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list, |
479 | legacy_dev_list) { | |
b3f2333d | 480 | list_del(&dev->legacy_dev_list); |
c94adc4a | 481 | drm_put_dev(dev); |
b3f2333d | 482 | } |
93711d8b BH |
483 | } |
484 | DRM_INFO("Module unloaded\n"); | |
485 | } | |
486 | EXPORT_SYMBOL(drm_pci_exit); |