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>
44 /**********************************************************************/
45 /** \name PCI memory */
49 * \brief Allocate a PCI consistent memory block, for DMA.
51 drm_dma_handle_t
*drm_pci_alloc(struct drm_device
* dev
, size_t size
, size_t align
)
53 drm_dma_handle_t
*dmah
;
57 /* pci_alloc_consistent only guarantees alignment to the smallest
58 * PAGE_SIZE order which is greater than or equal to the requested size.
59 * Return NULL here for now to make sure nobody tries for larger alignment
64 dmah
= kmalloc(sizeof(drm_dma_handle_t
), GFP_KERNEL
);
69 dmah
->vaddr
= dma_alloc_coherent(&dev
->pdev
->dev
, size
, &dmah
->busaddr
, GFP_KERNEL
| __GFP_COMP
);
71 if (dmah
->vaddr
== NULL
) {
76 memset(dmah
->vaddr
, 0, size
);
79 for (addr
= (unsigned long)dmah
->vaddr
, sz
= size
;
80 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
81 SetPageReserved(virt_to_page(addr
));
87 EXPORT_SYMBOL(drm_pci_alloc
);
90 * \brief Free a PCI consistent memory block without freeing its descriptor.
92 * This function is for internal use in the Linux-specific DRM core code.
94 void __drm_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
101 for (addr
= (unsigned long)dmah
->vaddr
, sz
= dmah
->size
;
102 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
103 ClearPageReserved(virt_to_page(addr
));
105 dma_free_coherent(&dev
->pdev
->dev
, dmah
->size
, dmah
->vaddr
,
111 * \brief Free a PCI consistent memory block
113 void drm_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
115 __drm_pci_free(dev
, dmah
);
119 EXPORT_SYMBOL(drm_pci_free
);
125 * \param pdev - PCI device structure
126 * \param ent entry from the PCI ID table with device type flags
127 * \return zero on success or a negative number on failure.
129 * Attempt to gets inter module "drm" information. If we are first
130 * then register the character device and inter module information.
131 * Try and register, if we fail to register, backout previous work.
133 int drm_get_pci_dev(struct pci_dev
*pdev
, const struct pci_device_id
*ent
,
134 struct drm_driver
*driver
)
136 struct drm_device
*dev
;
141 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
145 ret
= pci_enable_device(pdev
);
149 pci_set_master(pdev
);
152 dev
->dev
= &pdev
->dev
;
154 dev
->pci_device
= pdev
->device
;
155 dev
->pci_vendor
= pdev
->vendor
;
158 dev
->hose
= pdev
->sysdata
;
161 mutex_lock(&drm_global_mutex
);
163 if ((ret
= drm_fill_in_dev(dev
, ent
, driver
))) {
164 printk(KERN_ERR
"DRM: Fill_in_dev failed.\n");
168 if (drm_core_check_feature(dev
, DRIVER_MODESET
)) {
169 pci_set_drvdata(pdev
, dev
);
170 ret
= drm_get_minor(dev
, &dev
->control
, DRM_MINOR_CONTROL
);
175 if ((ret
= drm_get_minor(dev
, &dev
->primary
, DRM_MINOR_LEGACY
)))
178 if (dev
->driver
->load
) {
179 ret
= dev
->driver
->load(dev
, ent
->driver_data
);
184 /* setup the grouping for the legacy output */
185 if (drm_core_check_feature(dev
, DRIVER_MODESET
)) {
186 ret
= drm_mode_group_init_legacy_group(dev
,
187 &dev
->primary
->mode_group
);
192 list_add_tail(&dev
->driver_item
, &driver
->device_list
);
194 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
195 driver
->name
, driver
->major
, driver
->minor
, driver
->patchlevel
,
196 driver
->date
, pci_name(pdev
), dev
->primary
->index
);
198 mutex_unlock(&drm_global_mutex
);
202 drm_put_minor(&dev
->primary
);
204 if (drm_core_check_feature(dev
, DRIVER_MODESET
))
205 drm_put_minor(&dev
->control
);
207 pci_disable_device(pdev
);
210 mutex_unlock(&drm_global_mutex
);
213 EXPORT_SYMBOL(drm_get_pci_dev
);
216 * PCI device initialization. Called via drm_init at module load time,
218 * \return zero on success or a negative number on failure.
220 * Initializes a drm_device structures,registering the
221 * stubs and initializing the AGP device.
223 * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
224 * after the initialization for driver customization.
226 int drm_pci_init(struct drm_driver
*driver
)
228 struct pci_dev
*pdev
= NULL
;
229 const struct pci_device_id
*pid
;
232 if (driver
->driver_features
& DRIVER_MODESET
)
233 return pci_register_driver(&driver
->pci_driver
);
235 /* If not using KMS, fall back to stealth mode manual scanning. */
236 for (i
= 0; driver
->pci_driver
.id_table
[i
].vendor
!= 0; i
++) {
237 pid
= &driver
->pci_driver
.id_table
[i
];
239 /* Loop around setting up a DRM device for each PCI device
240 * matching our ID and device class. If we had the internal
241 * function that pci_get_subsys and pci_get_class used, we'd
242 * be able to just pass pid in instead of doing a two-stage
247 pci_get_subsys(pid
->vendor
, pid
->device
, pid
->subvendor
,
248 pid
->subdevice
, pdev
)) != NULL
) {
249 if ((pdev
->class & pid
->class_mask
) != pid
->class)
252 /* stealth mode requires a manual probe */
254 drm_get_pci_dev(pdev
, pid
, driver
);
262 int drm_pci_init(struct drm_driver
*driver
)