1 /* drm_pci.h -- PCI DMA memory management wrappers for DRM -*- linux-c -*- */
4 * \brief Functions and ioctls to manage PCI memory
6 * \warning These interfaces aren't stable yet.
8 * \todo Implement the remaining ioctl's for the PCI pools.
9 * \todo The wrappers here are so thin that they would be better off inlined..
11 * \author José Fonseca <jrfonseca@tungstengraphics.com>
12 * \author Leif Delgass <ldelgass@retinalburn.net>
16 * Copyright 2003 José Fonseca.
17 * Copyright 2003 Leif Delgass.
18 * All Rights Reserved.
20 * Permission is hereby granted, free of charge, to any person obtaining a
21 * copy of this software and associated documentation files (the "Software"),
22 * to deal in the Software without restriction, including without limitation
23 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
24 * and/or sell copies of the Software, and to permit persons to whom the
25 * Software is furnished to do so, subject to the following conditions:
27 * The above copyright notice and this permission notice (including the next
28 * paragraph) shall be included in all copies or substantial portions of the
31 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
32 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
33 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
34 * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
35 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
36 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
39 #include <linux/pci.h>
40 #include <linux/slab.h>
41 #include <linux/dma-mapping.h>
42 #include <linux/export.h>
45 /**********************************************************************/
46 /** \name PCI memory */
50 * \brief Allocate a PCI consistent memory block, for DMA.
52 drm_dma_handle_t
*drm_pci_alloc(struct drm_device
* dev
, size_t size
, size_t align
)
54 drm_dma_handle_t
*dmah
;
58 /* pci_alloc_consistent only guarantees alignment to the smallest
59 * PAGE_SIZE order which is greater than or equal to the requested size.
60 * Return NULL here for now to make sure nobody tries for larger alignment
65 dmah
= kmalloc(sizeof(drm_dma_handle_t
), GFP_KERNEL
);
70 dmah
->vaddr
= dma_alloc_coherent(&dev
->pdev
->dev
, size
, &dmah
->busaddr
, GFP_KERNEL
| __GFP_COMP
);
72 if (dmah
->vaddr
== NULL
) {
77 memset(dmah
->vaddr
, 0, size
);
79 /* XXX - Is virt_to_page() legal for consistent mem? */
81 for (addr
= (unsigned long)dmah
->vaddr
, sz
= size
;
82 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
83 SetPageReserved(virt_to_page((void *)addr
));
89 EXPORT_SYMBOL(drm_pci_alloc
);
92 * \brief Free a PCI consistent memory block without freeing its descriptor.
94 * This function is for internal use in the Linux-specific DRM core code.
96 void __drm_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
102 /* XXX - Is virt_to_page() legal for consistent mem? */
104 for (addr
= (unsigned long)dmah
->vaddr
, sz
= dmah
->size
;
105 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
106 ClearPageReserved(virt_to_page((void *)addr
));
108 dma_free_coherent(&dev
->pdev
->dev
, dmah
->size
, dmah
->vaddr
,
114 * \brief Free a PCI consistent memory block
116 void drm_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
118 __drm_pci_free(dev
, dmah
);
122 EXPORT_SYMBOL(drm_pci_free
);
126 static int drm_get_pci_domain(struct drm_device
*dev
)
129 /* For historical reasons, drm_get_pci_domain() is busticated
130 * on most archs and has to remain so for userspace interface
131 * < 1.4, except on alpha which was right from the beginning
133 if (dev
->if_version
< 0x10004)
135 #endif /* __alpha__ */
137 return pci_domain_nr(dev
->pdev
->bus
);
140 static int drm_pci_set_busid(struct drm_device
*dev
, struct drm_master
*master
)
143 master
->unique_len
= 40;
144 master
->unique_size
= master
->unique_len
;
145 master
->unique
= kmalloc(master
->unique_size
, GFP_KERNEL
);
146 if (master
->unique
== NULL
)
150 len
= snprintf(master
->unique
, master
->unique_len
,
151 "pci:%04x:%02x:%02x.%d",
152 drm_get_pci_domain(dev
),
153 dev
->pdev
->bus
->number
,
154 PCI_SLOT(dev
->pdev
->devfn
),
155 PCI_FUNC(dev
->pdev
->devfn
));
157 if (len
>= master
->unique_len
) {
158 DRM_ERROR("buffer overflow");
162 master
->unique_len
= len
;
169 int drm_pci_set_unique(struct drm_device
*dev
,
170 struct drm_master
*master
,
171 struct drm_unique
*u
)
173 int domain
, bus
, slot
, func
, ret
;
175 master
->unique_len
= u
->unique_len
;
176 master
->unique_size
= u
->unique_len
+ 1;
177 master
->unique
= kmalloc(master
->unique_size
, GFP_KERNEL
);
178 if (!master
->unique
) {
183 if (copy_from_user(master
->unique
, u
->unique
, master
->unique_len
)) {
188 master
->unique
[master
->unique_len
] = '\0';
190 /* Return error if the busid submitted doesn't match the device's actual
193 ret
= sscanf(master
->unique
, "PCI:%d:%d:%d", &bus
, &slot
, &func
);
202 if ((domain
!= drm_get_pci_domain(dev
)) ||
203 (bus
!= dev
->pdev
->bus
->number
) ||
204 (slot
!= PCI_SLOT(dev
->pdev
->devfn
)) ||
205 (func
!= PCI_FUNC(dev
->pdev
->devfn
))) {
214 static int drm_pci_irq_by_busid(struct drm_device
*dev
, struct drm_irq_busid
*p
)
216 if ((p
->busnum
>> 8) != drm_get_pci_domain(dev
) ||
217 (p
->busnum
& 0xff) != dev
->pdev
->bus
->number
||
218 p
->devnum
!= PCI_SLOT(dev
->pdev
->devfn
) || p
->funcnum
!= PCI_FUNC(dev
->pdev
->devfn
))
221 p
->irq
= dev
->pdev
->irq
;
223 DRM_DEBUG("%d:%d:%d => IRQ %d\n", p
->busnum
, p
->devnum
, p
->funcnum
,
229 * Get interrupt from bus id.
231 * \param inode device inode.
232 * \param file_priv DRM file private.
233 * \param cmd command.
234 * \param arg user argument, pointing to a drm_irq_busid structure.
235 * \return zero on success or a negative number on failure.
237 * Finds the PCI device with the specified bus id and gets its IRQ number.
238 * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
239 * to that of the device that this DRM instance attached to.
241 int drm_irq_by_busid(struct drm_device
*dev
, void *data
,
242 struct drm_file
*file_priv
)
244 struct drm_irq_busid
*p
= data
;
246 if (drm_core_check_feature(dev
, DRIVER_MODESET
))
249 /* UMS was only ever support on PCI devices. */
250 if (WARN_ON(!dev
->pdev
))
253 if (!drm_core_check_feature(dev
, DRIVER_HAVE_IRQ
))
256 return drm_pci_irq_by_busid(dev
, p
);
259 static void drm_pci_agp_init(struct drm_device
*dev
)
261 if (drm_core_check_feature(dev
, DRIVER_USE_AGP
)) {
262 if (drm_pci_device_is_agp(dev
))
263 dev
->agp
= drm_agp_init(dev
);
265 dev
->agp
->agp_mtrr
= arch_phys_wc_add(
266 dev
->agp
->agp_info
.aper_base
,
267 dev
->agp
->agp_info
.aper_size
*
273 void drm_pci_agp_destroy(struct drm_device
*dev
)
276 arch_phys_wc_del(dev
->agp
->agp_mtrr
);
283 static struct drm_bus drm_pci_bus
= {
284 .set_busid
= drm_pci_set_busid
,
290 * \param pdev - PCI device structure
291 * \param ent entry from the PCI ID table with device type flags
292 * \return zero on success or a negative number on failure.
294 * Attempt to gets inter module "drm" information. If we are first
295 * then register the character device and inter module information.
296 * Try and register, if we fail to register, backout previous work.
298 int drm_get_pci_dev(struct pci_dev
*pdev
, const struct pci_device_id
*ent
,
299 struct drm_driver
*driver
)
301 struct drm_device
*dev
;
306 dev
= drm_dev_alloc(driver
, &pdev
->dev
);
310 ret
= pci_enable_device(pdev
);
316 dev
->hose
= pdev
->sysdata
;
319 if (drm_core_check_feature(dev
, DRIVER_MODESET
))
320 pci_set_drvdata(pdev
, dev
);
322 drm_pci_agp_init(dev
);
324 ret
= drm_dev_register(dev
, ent
->driver_data
);
328 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
329 driver
->name
, driver
->major
, driver
->minor
, driver
->patchlevel
,
330 driver
->date
, pci_name(pdev
), dev
->primary
->index
);
332 /* No locking needed since shadow-attach is single-threaded since it may
333 * only be called from the per-driver module init hook. */
334 if (!drm_core_check_feature(dev
, DRIVER_MODESET
))
335 list_add_tail(&dev
->legacy_dev_list
, &driver
->legacy_dev_list
);
340 drm_pci_agp_destroy(dev
);
341 pci_disable_device(pdev
);
346 EXPORT_SYMBOL(drm_get_pci_dev
);
349 * PCI device initialization. Called direct from modules at load time.
351 * \return zero on success or a negative number on failure.
353 * Initializes a drm_device structures,registering the
354 * stubs and initializing the AGP device.
356 * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
357 * after the initialization for driver customization.
359 int drm_pci_init(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
361 struct pci_dev
*pdev
= NULL
;
362 const struct pci_device_id
*pid
;
367 driver
->bus
= &drm_pci_bus
;
369 if (driver
->driver_features
& DRIVER_MODESET
)
370 return pci_register_driver(pdriver
);
372 /* If not using KMS, fall back to stealth mode manual scanning. */
373 INIT_LIST_HEAD(&driver
->legacy_dev_list
);
374 for (i
= 0; pdriver
->id_table
[i
].vendor
!= 0; i
++) {
375 pid
= &pdriver
->id_table
[i
];
377 /* Loop around setting up a DRM device for each PCI device
378 * matching our ID and device class. If we had the internal
379 * function that pci_get_subsys and pci_get_class used, we'd
380 * be able to just pass pid in instead of doing a two-stage
385 pci_get_subsys(pid
->vendor
, pid
->device
, pid
->subvendor
,
386 pid
->subdevice
, pdev
)) != NULL
) {
387 if ((pdev
->class & pid
->class_mask
) != pid
->class)
390 /* stealth mode requires a manual probe */
392 drm_get_pci_dev(pdev
, pid
, driver
);
398 int drm_pcie_get_speed_cap_mask(struct drm_device
*dev
, u32
*mask
)
400 struct pci_dev
*root
;
407 root
= dev
->pdev
->bus
->self
;
409 /* we've been informed via and serverworks don't make the cut */
410 if (root
->vendor
== PCI_VENDOR_ID_VIA
||
411 root
->vendor
== PCI_VENDOR_ID_SERVERWORKS
)
414 pcie_capability_read_dword(root
, PCI_EXP_LNKCAP
, &lnkcap
);
415 pcie_capability_read_dword(root
, PCI_EXP_LNKCAP2
, &lnkcap2
);
417 if (lnkcap2
) { /* PCIe r3.0-compliant */
418 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_2_5GB
)
419 *mask
|= DRM_PCIE_SPEED_25
;
420 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_5_0GB
)
421 *mask
|= DRM_PCIE_SPEED_50
;
422 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_8_0GB
)
423 *mask
|= DRM_PCIE_SPEED_80
;
424 } else { /* pre-r3.0 */
425 if (lnkcap
& PCI_EXP_LNKCAP_SLS_2_5GB
)
426 *mask
|= DRM_PCIE_SPEED_25
;
427 if (lnkcap
& PCI_EXP_LNKCAP_SLS_5_0GB
)
428 *mask
|= (DRM_PCIE_SPEED_25
| DRM_PCIE_SPEED_50
);
431 DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root
->vendor
, root
->device
, lnkcap
, lnkcap2
);
434 EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask
);
438 int drm_pci_init(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
443 void drm_pci_agp_destroy(struct drm_device
*dev
) {}
445 int drm_irq_by_busid(struct drm_device
*dev
, void *data
,
446 struct drm_file
*file_priv
)
451 int drm_pci_set_unique(struct drm_device
*dev
,
452 struct drm_master
*master
,
453 struct drm_unique
*u
)
459 EXPORT_SYMBOL(drm_pci_init
);
462 void drm_pci_exit(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
464 struct drm_device
*dev
, *tmp
;
467 if (driver
->driver_features
& DRIVER_MODESET
) {
468 pci_unregister_driver(pdriver
);
470 list_for_each_entry_safe(dev
, tmp
, &driver
->legacy_dev_list
,
472 list_del(&dev
->legacy_dev_list
);
476 DRM_INFO("Module unloaded\n");
478 EXPORT_SYMBOL(drm_pci_exit
);