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(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(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_get_irq(struct drm_device
*dev
)
142 return dev
->pdev
->irq
;
145 static const char *drm_pci_get_name(struct drm_device
*dev
)
147 struct pci_driver
*pdriver
= dev
->driver
->kdriver
.pci
;
148 return pdriver
->name
;
151 static int drm_pci_set_busid(struct drm_device
*dev
, struct drm_master
*master
)
154 struct pci_driver
*pdriver
= dev
->driver
->kdriver
.pci
;
155 master
->unique_len
= 40;
156 master
->unique_size
= master
->unique_len
;
157 master
->unique
= kmalloc(master
->unique_size
, GFP_KERNEL
);
158 if (master
->unique
== NULL
)
162 len
= snprintf(master
->unique
, master
->unique_len
,
163 "pci:%04x:%02x:%02x.%d",
164 drm_get_pci_domain(dev
),
165 dev
->pdev
->bus
->number
,
166 PCI_SLOT(dev
->pdev
->devfn
),
167 PCI_FUNC(dev
->pdev
->devfn
));
169 if (len
>= master
->unique_len
) {
170 DRM_ERROR("buffer overflow");
174 master
->unique_len
= len
;
177 kmalloc(strlen(pdriver
->name
) +
178 master
->unique_len
+ 2, GFP_KERNEL
);
180 if (dev
->devname
== NULL
) {
185 sprintf(dev
->devname
, "%s@%s", pdriver
->name
,
193 static int drm_pci_set_unique(struct drm_device
*dev
,
194 struct drm_master
*master
,
195 struct drm_unique
*u
)
197 int domain
, bus
, slot
, func
, ret
;
198 const char *bus_name
;
200 master
->unique_len
= u
->unique_len
;
201 master
->unique_size
= u
->unique_len
+ 1;
202 master
->unique
= kmalloc(master
->unique_size
, GFP_KERNEL
);
203 if (!master
->unique
) {
208 if (copy_from_user(master
->unique
, u
->unique
, master
->unique_len
)) {
213 master
->unique
[master
->unique_len
] = '\0';
215 bus_name
= dev
->driver
->bus
->get_name(dev
);
216 dev
->devname
= kmalloc(strlen(bus_name
) +
217 strlen(master
->unique
) + 2, GFP_KERNEL
);
223 sprintf(dev
->devname
, "%s@%s", bus_name
,
226 /* Return error if the busid submitted doesn't match the device's actual
229 ret
= sscanf(master
->unique
, "PCI:%d:%d:%d", &bus
, &slot
, &func
);
238 if ((domain
!= drm_get_pci_domain(dev
)) ||
239 (bus
!= dev
->pdev
->bus
->number
) ||
240 (slot
!= PCI_SLOT(dev
->pdev
->devfn
)) ||
241 (func
!= PCI_FUNC(dev
->pdev
->devfn
))) {
251 static int drm_pci_irq_by_busid(struct drm_device
*dev
, struct drm_irq_busid
*p
)
253 if ((p
->busnum
>> 8) != drm_get_pci_domain(dev
) ||
254 (p
->busnum
& 0xff) != dev
->pdev
->bus
->number
||
255 p
->devnum
!= PCI_SLOT(dev
->pdev
->devfn
) || p
->funcnum
!= PCI_FUNC(dev
->pdev
->devfn
))
258 p
->irq
= dev
->pdev
->irq
;
260 DRM_DEBUG("%d:%d:%d => IRQ %d\n", p
->busnum
, p
->devnum
, p
->funcnum
,
265 static int drm_pci_agp_init(struct drm_device
*dev
)
267 if (drm_core_has_AGP(dev
)) {
268 if (drm_pci_device_is_agp(dev
))
269 dev
->agp
= drm_agp_init(dev
);
270 if (drm_core_check_feature(dev
, DRIVER_REQUIRE_AGP
)
271 && (dev
->agp
== NULL
)) {
272 DRM_ERROR("Cannot initialize the agpgart module.\n");
276 dev
->agp
->agp_mtrr
= arch_phys_wc_add(
277 dev
->agp
->agp_info
.aper_base
,
278 dev
->agp
->agp_info
.aper_size
*
285 static void drm_pci_agp_destroy(struct drm_device
*dev
)
287 if (drm_core_has_AGP(dev
) && dev
->agp
) {
288 arch_phys_wc_del(dev
->agp
->agp_mtrr
);
290 drm_agp_destroy(dev
->agp
);
295 static struct drm_bus drm_pci_bus
= {
296 .bus_type
= DRIVER_BUS_PCI
,
297 .get_irq
= drm_pci_get_irq
,
298 .get_name
= drm_pci_get_name
,
299 .set_busid
= drm_pci_set_busid
,
300 .set_unique
= drm_pci_set_unique
,
301 .irq_by_busid
= drm_pci_irq_by_busid
,
302 .agp_init
= drm_pci_agp_init
,
303 .agp_destroy
= drm_pci_agp_destroy
,
309 * \param pdev - PCI device structure
310 * \param ent entry from the PCI ID table with device type flags
311 * \return zero on success or a negative number on failure.
313 * Attempt to gets inter module "drm" information. If we are first
314 * then register the character device and inter module information.
315 * Try and register, if we fail to register, backout previous work.
317 int drm_get_pci_dev(struct pci_dev
*pdev
, const struct pci_device_id
*ent
,
318 struct drm_driver
*driver
)
320 struct drm_device
*dev
;
325 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
329 ret
= pci_enable_device(pdev
);
334 dev
->dev
= &pdev
->dev
;
336 dev
->pci_device
= pdev
->device
;
337 dev
->pci_vendor
= pdev
->vendor
;
340 dev
->hose
= pdev
->sysdata
;
343 mutex_lock(&drm_global_mutex
);
345 if ((ret
= drm_fill_in_dev(dev
, ent
, driver
))) {
346 printk(KERN_ERR
"DRM: Fill_in_dev failed.\n");
350 if (drm_core_check_feature(dev
, DRIVER_MODESET
)) {
351 pci_set_drvdata(pdev
, dev
);
352 ret
= drm_get_minor(dev
, &dev
->control
, DRM_MINOR_CONTROL
);
357 if (drm_core_check_feature(dev
, DRIVER_RENDER
) && drm_rnodes
) {
358 ret
= drm_get_minor(dev
, &dev
->render
, DRM_MINOR_RENDER
);
363 if ((ret
= drm_get_minor(dev
, &dev
->primary
, DRM_MINOR_LEGACY
)))
366 if (dev
->driver
->load
) {
367 ret
= dev
->driver
->load(dev
, ent
->driver_data
);
372 /* setup the grouping for the legacy output */
373 if (drm_core_check_feature(dev
, DRIVER_MODESET
)) {
374 ret
= drm_mode_group_init_legacy_group(dev
,
375 &dev
->primary
->mode_group
);
380 list_add_tail(&dev
->driver_item
, &driver
->device_list
);
382 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
383 driver
->name
, driver
->major
, driver
->minor
, driver
->patchlevel
,
384 driver
->date
, pci_name(pdev
), dev
->primary
->index
);
386 mutex_unlock(&drm_global_mutex
);
390 drm_put_minor(&dev
->primary
);
393 drm_put_minor(&dev
->render
);
395 if (drm_core_check_feature(dev
, DRIVER_MODESET
))
396 drm_put_minor(&dev
->control
);
398 pci_disable_device(pdev
);
401 mutex_unlock(&drm_global_mutex
);
404 EXPORT_SYMBOL(drm_get_pci_dev
);
407 * PCI device initialization. Called direct from modules at load time.
409 * \return zero on success or a negative number on failure.
411 * Initializes a drm_device structures,registering the
412 * stubs and initializing the AGP device.
414 * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
415 * after the initialization for driver customization.
417 int drm_pci_init(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
419 struct pci_dev
*pdev
= NULL
;
420 const struct pci_device_id
*pid
;
425 INIT_LIST_HEAD(&driver
->device_list
);
426 driver
->kdriver
.pci
= pdriver
;
427 driver
->bus
= &drm_pci_bus
;
429 if (driver
->driver_features
& DRIVER_MODESET
)
430 return pci_register_driver(pdriver
);
432 /* If not using KMS, fall back to stealth mode manual scanning. */
433 for (i
= 0; pdriver
->id_table
[i
].vendor
!= 0; i
++) {
434 pid
= &pdriver
->id_table
[i
];
436 /* Loop around setting up a DRM device for each PCI device
437 * matching our ID and device class. If we had the internal
438 * function that pci_get_subsys and pci_get_class used, we'd
439 * be able to just pass pid in instead of doing a two-stage
444 pci_get_subsys(pid
->vendor
, pid
->device
, pid
->subvendor
,
445 pid
->subdevice
, pdev
)) != NULL
) {
446 if ((pdev
->class & pid
->class_mask
) != pid
->class)
449 /* stealth mode requires a manual probe */
451 drm_get_pci_dev(pdev
, pid
, driver
);
457 int drm_pcie_get_speed_cap_mask(struct drm_device
*dev
, u32
*mask
)
459 struct pci_dev
*root
;
466 root
= dev
->pdev
->bus
->self
;
468 /* we've been informed via and serverworks don't make the cut */
469 if (root
->vendor
== PCI_VENDOR_ID_VIA
||
470 root
->vendor
== PCI_VENDOR_ID_SERVERWORKS
)
473 pcie_capability_read_dword(root
, PCI_EXP_LNKCAP
, &lnkcap
);
474 pcie_capability_read_dword(root
, PCI_EXP_LNKCAP2
, &lnkcap2
);
476 if (lnkcap2
) { /* PCIe r3.0-compliant */
477 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_2_5GB
)
478 *mask
|= DRM_PCIE_SPEED_25
;
479 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_5_0GB
)
480 *mask
|= DRM_PCIE_SPEED_50
;
481 if (lnkcap2
& PCI_EXP_LNKCAP2_SLS_8_0GB
)
482 *mask
|= DRM_PCIE_SPEED_80
;
483 } else { /* pre-r3.0 */
484 if (lnkcap
& PCI_EXP_LNKCAP_SLS_2_5GB
)
485 *mask
|= DRM_PCIE_SPEED_25
;
486 if (lnkcap
& PCI_EXP_LNKCAP_SLS_5_0GB
)
487 *mask
|= (DRM_PCIE_SPEED_25
| DRM_PCIE_SPEED_50
);
490 DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root
->vendor
, root
->device
, lnkcap
, lnkcap2
);
493 EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask
);
497 int drm_pci_init(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
504 EXPORT_SYMBOL(drm_pci_init
);
507 void drm_pci_exit(struct drm_driver
*driver
, struct pci_driver
*pdriver
)
509 struct drm_device
*dev
, *tmp
;
512 if (driver
->driver_features
& DRIVER_MODESET
) {
513 pci_unregister_driver(pdriver
);
515 list_for_each_entry_safe(dev
, tmp
, &driver
->device_list
, driver_item
)
518 DRM_INFO("Module unloaded\n");
520 EXPORT_SYMBOL(drm_pci_exit
);