2 * Copyright 2003 José Fonseca.
3 * Copyright 2003 Leif Delgass.
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:
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
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.
25 #include <linux/pci.h>
26 #include <linux/slab.h>
27 #include <linux/dma-mapping.h>
28 #include <linux/export.h>
29 #include <drm/drm_pci.h>
31 #include "drm_internal.h"
32 #include "drm_legacy.h"
35 * drm_pci_alloc - Allocate a PCI consistent memory block, for DMA.
37 * @size: size of block to allocate
38 * @align: alignment of block
40 * FIXME: This is a needless abstraction of the Linux dma-api and should be
43 * Return: A handle to the allocated memory block on success or NULL on
46 drm_dma_handle_t
*drm_pci_alloc(struct drm_device
* dev
, size_t size
, size_t align
)
48 drm_dma_handle_t
*dmah
;
52 /* pci_alloc_consistent only guarantees alignment to the smallest
53 * PAGE_SIZE order which is greater than or equal to the requested size.
54 * Return NULL here for now to make sure nobody tries for larger alignment
59 dmah
= kmalloc(sizeof(drm_dma_handle_t
), M_DRM
, GFP_KERNEL
);
64 dmah
->vaddr
= dma_alloc_coherent(&dev
->pdev
->dev
, size
, &dmah
->busaddr
, GFP_KERNEL
);
66 if (dmah
->vaddr
== NULL
) {
71 memset(dmah
->vaddr
, 0, size
);
73 /* XXX - Is virt_to_page() legal for consistent mem? */
75 for (addr
= (unsigned long)dmah
->vaddr
, sz
= size
;
76 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
78 SetPageReserved(virt_to_page((void *)addr
));
85 EXPORT_SYMBOL(drm_pci_alloc
);
88 * Free a PCI consistent memory block without freeing its descriptor.
90 * This function is for internal use in the Linux-specific DRM core code.
92 void __drm_legacy_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
98 /* XXX - Is virt_to_page() legal for consistent mem? */
100 for (addr
= (unsigned long)dmah
->vaddr
, sz
= dmah
->size
;
101 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
103 ClearPageReserved(virt_to_page((void *)addr
));
106 dma_free_coherent(&dev
->pdev
->dev
, dmah
->size
, dmah
->vaddr
,
112 * drm_pci_free - Free a PCI consistent memory block
114 * @dmah: handle to memory block
116 * FIXME: This is a needless abstraction of the Linux dma-api and should be
119 void drm_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
121 __drm_legacy_pci_free(dev
, dmah
);
125 EXPORT_SYMBOL(drm_pci_free
);
129 static int drm_get_pci_domain(struct drm_device
*dev
)
132 /* For historical reasons, drm_get_pci_domain() is busticated
133 * on most archs and has to remain so for userspace interface
134 * < 1.4, except on alpha which was right from the beginning
136 if (dev
->if_version
< 0x10004)
138 #endif /* __alpha__ */
141 return pci_domain_nr(dev
->pdev
->bus
);
143 return dev
->pci_domain
;
147 int drm_pci_set_busid(struct drm_device
*dev
, struct drm_master
*master
)
149 master
->unique
= kasprintf(GFP_KERNEL
, "pci:%04x:%02x:%02x.%d",
150 drm_get_pci_domain(dev
),
151 dev
->pdev
->bus
->number
,
152 PCI_SLOT(dev
->pdev
->devfn
),
153 PCI_FUNC(dev
->pdev
->devfn
));
157 master
->unique_len
= strlen(master
->unique
);
161 static int drm_pci_irq_by_busid(struct drm_device
*dev
, struct drm_irq_busid
*p
)
163 if ((p
->busnum
>> 8) != drm_get_pci_domain(dev
) ||
164 (p
->busnum
& 0xff) != dev
->pdev
->bus
->number
||
165 p
->devnum
!= PCI_SLOT(dev
->pdev
->devfn
) || p
->funcnum
!= PCI_FUNC(dev
->pdev
->devfn
))
168 p
->irq
= dev
->pdev
->irq
;
170 DRM_DEBUG("%d:%d:%d => IRQ %d\n", p
->busnum
, p
->devnum
, p
->funcnum
,
176 * drm_irq_by_busid - Get interrupt from bus ID
178 * @data: IOCTL parameter pointing to a drm_irq_busid structure
179 * @file_priv: DRM file private.
181 * Finds the PCI device with the specified bus id and gets its IRQ number.
182 * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
183 * to that of the device that this DRM instance attached to.
185 * Return: 0 on success or a negative error code on failure.
187 int drm_irq_by_busid(struct drm_device
*dev
, void *data
,
188 struct drm_file
*file_priv
)
190 struct drm_irq_busid
*p
= data
;
192 if (!drm_core_check_feature(dev
, DRIVER_LEGACY
))
195 /* UMS was only ever support on PCI devices. */
196 if (WARN_ON(!dev
->pdev
))
199 if (!drm_core_check_feature(dev
, DRIVER_HAVE_IRQ
))
202 return drm_pci_irq_by_busid(dev
, p
);
207 drm_getpciinfo(struct drm_device
*dev
, void *data
, struct drm_file
*file_priv
)
209 struct drm_pciinfo
*info
= data
;
212 info
->bus
= dev
->pci_bus
;
213 info
->dev
= PCI_SLOT(dev
->pdev
->devfn
);
214 info
->func
= PCI_FUNC(dev
->pdev
->devfn
);
215 info
->vendor_id
= dev
->pdev
->vendor
;
216 info
->device_id
= dev
->pdev
->device
;
217 info
->subvendor_id
= dev
->pdev
->subsystem_vendor
;
218 info
->subdevice_id
= dev
->pdev
->subsystem_device
;
219 info
->revision_id
= 0;
226 * drm_get_pci_dev - Register a PCI device with the DRM subsystem
228 * @ent: entry from the PCI ID table that matches @pdev
229 * @driver: DRM device driver
231 * Attempt to gets inter module "drm" information. If we are first
232 * then register the character device and inter module information.
233 * Try and register, if we fail to register, backout previous work.
235 * NOTE: This function is deprecated, please use drm_dev_alloc() and
236 * drm_dev_register() instead and remove your &drm_driver.load callback.
238 * Return: 0 on success or a negative error code on failure.
240 int drm_get_pci_dev(struct pci_dev
*pdev
, const struct pci_device_id
*ent
,
241 struct drm_driver
*driver
)
243 struct drm_device
*dev
;
248 dev
= drm_dev_alloc(driver
, &pdev
->dev
);
253 ret
= pci_enable_device(pdev
);
260 dev
->hose
= pdev
->sysdata
;
263 if (drm_core_check_feature(dev
, DRIVER_MODESET
))
264 pci_set_drvdata(pdev
, dev
);
267 drm_pci_agp_init(dev
);
270 ret
= drm_dev_register(dev
, ent
->driver_data
);
274 /* No locking needed since shadow-attach is single-threaded since it may
275 * only be called from the per-driver module init hook. */
276 if (drm_core_check_feature(dev
, DRIVER_LEGACY
))
277 list_add_tail(&dev
->legacy_dev_list
, &driver
->legacy_dev_list
);
283 drm_pci_agp_destroy(dev
);
284 pci_disable_device(pdev
);
290 EXPORT_SYMBOL(drm_get_pci_dev
);
293 * drm_legacy_pci_init - shadow-attach a legacy DRM PCI driver
294 * @driver: DRM device driver
295 * @pdriver: PCI device driver
297 * This is only used by legacy dri1 drivers and deprecated.
299 * Return: 0 on success or a negative error code on failure.
301 int drm_legacy_pci_init(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
304 struct pci_dev
*pdev
= NULL
;
305 const struct pci_device_id
*pid
;
311 if (WARN_ON(!(driver
->driver_features
& DRIVER_LEGACY
)))
315 /* If not using KMS, fall back to stealth mode manual scanning. */
316 INIT_LIST_HEAD(&driver
->legacy_dev_list
);
317 for (i
= 0; pdriver
->id_table
[i
].vendor
!= 0; i
++) {
318 pid
= &pdriver
->id_table
[i
];
320 /* Loop around setting up a DRM device for each PCI device
321 * matching our ID and device class. If we had the internal
322 * function that pci_get_subsys and pci_get_class used, we'd
323 * be able to just pass pid in instead of doing a two-stage
328 pci_get_subsys(pid
->vendor
, pid
->device
, pid
->subvendor
,
329 pid
->subdevice
, pdev
)) != NULL
) {
330 if ((pdev
->class & pid
->class_mask
) != pid
->class)
333 /* stealth mode requires a manual probe */
335 drm_get_pci_dev(pdev
, pid
, driver
);
341 EXPORT_SYMBOL(drm_legacy_pci_init
);
343 int drm_pcie_get_speed_cap_mask(struct drm_device
*dev
, u32
*mask
)
345 struct pci_dev
*root
;
352 root
= dev
->pdev
->bus
->self
;
354 /* we've been informed via and serverworks don't make the cut */
355 if (root
->vendor
== PCI_VENDOR_ID_VIA
||
356 root
->vendor
== PCI_VENDOR_ID_SERVERWORKS
)
359 pcie_capability_read_dword(root
, PCI_EXP_LNKCAP
, &lnkcap
);
360 pcie_capability_read_dword(root
, PCI_EXP_LNKCAP2
, &lnkcap2
);
362 if (lnkcap2
) { /* PCIe r3.0-compliant */
363 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_2_5GB
)
364 *mask
|= DRM_PCIE_SPEED_25
;
365 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_5_0GB
)
366 *mask
|= DRM_PCIE_SPEED_50
;
367 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_8_0GB
)
368 *mask
|= DRM_PCIE_SPEED_80
;
369 } else { /* pre-r3.0 */
370 if (lnkcap
& PCI_EXP_LNKCAP_SLS_2_5GB
)
371 *mask
|= DRM_PCIE_SPEED_25
;
372 if (lnkcap
& PCI_EXP_LNKCAP_SLS_5_0GB
)
373 *mask
|= (DRM_PCIE_SPEED_25
| DRM_PCIE_SPEED_50
);
376 DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root
->vendor
, root
->device
, lnkcap
, lnkcap2
);
379 EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask
);
381 int drm_pcie_get_max_link_width(struct drm_device
*dev
, u32
*mlw
)
383 struct pci_dev
*root
;
390 root
= dev
->pdev
->bus
->self
;
392 pcie_capability_read_dword(root
, PCI_EXP_LNKCAP
, &lnkcap
);
394 *mlw
= (lnkcap
& PCI_EXP_LNKCAP_MLW
) >> 4;
396 DRM_INFO("probing mlw for device %x:%x = %x\n", root
->vendor
, root
->device
, lnkcap
);
399 EXPORT_SYMBOL(drm_pcie_get_max_link_width
);
403 void drm_pci_agp_destroy(struct drm_device
*dev
) {}
405 int drm_irq_by_busid(struct drm_device
*dev
, void *data
,
406 struct drm_file
*file_priv
)
413 * drm_legacy_pci_exit - unregister shadow-attach legacy DRM driver
414 * @driver: DRM device driver
415 * @pdriver: PCI device driver
417 * Unregister a DRM driver shadow-attached through drm_legacy_pci_init(). This
418 * is deprecated and only used by dri1 drivers.
420 void drm_legacy_pci_exit(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
422 struct drm_device
*dev
, *tmp
;
425 if (!(driver
->driver_features
& DRIVER_LEGACY
)) {
428 list_for_each_entry_safe(dev
, tmp
, &driver
->legacy_dev_list
,
430 list_del(&dev
->legacy_dev_list
);
436 DRM_INFO("Module unloaded\n");
438 EXPORT_SYMBOL(drm_legacy_pci_exit
);