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
;
59 /* pci_alloc_consistent only guarantees alignment to the smallest
60 * PAGE_SIZE order which is greater than or equal to the requested size.
61 * Return NULL here for now to make sure nobody tries for larger alignment
66 dmah
= kmalloc(sizeof(drm_dma_handle_t
), GFP_KERNEL
);
71 dmah
->vaddr
= dma_alloc_coherent(&dev
->pdev
->dev
, size
, &dmah
->busaddr
, GFP_KERNEL
| __GFP_COMP
);
73 if (dmah
->vaddr
== NULL
) {
78 memset(dmah
->vaddr
, 0, size
);
80 /* XXX - Is virt_to_page() legal for consistent mem? */
82 for (addr
= (unsigned long)dmah
->vaddr
, sz
= size
;
83 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
84 SetPageReserved(virt_to_page(addr
));
90 EXPORT_SYMBOL(drm_pci_alloc
);
93 * \brief Free a PCI consistent memory block without freeing its descriptor.
95 * This function is for internal use in the Linux-specific DRM core code.
97 void __drm_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
105 /* XXX - Is virt_to_page() legal for consistent mem? */
107 for (addr
= (unsigned long)dmah
->vaddr
, sz
= dmah
->size
;
108 sz
> 0; addr
+= PAGE_SIZE
, sz
-= PAGE_SIZE
) {
109 ClearPageReserved(virt_to_page(addr
));
111 dma_free_coherent(&dev
->pdev
->dev
, dmah
->size
, dmah
->vaddr
,
117 * \brief Free a PCI consistent memory block
119 void drm_pci_free(struct drm_device
* dev
, drm_dma_handle_t
* dmah
)
121 __drm_pci_free(dev
, dmah
);
125 EXPORT_SYMBOL(drm_pci_free
);
131 * \param pdev - PCI device structure
132 * \param ent entry from the PCI ID table with device type flags
133 * \return zero on success or a negative number on failure.
135 * Attempt to gets inter module "drm" information. If we are first
136 * then register the character device and inter module information.
137 * Try and register, if we fail to register, backout previous work.
139 int drm_get_pci_dev(struct pci_dev
*pdev
, const struct pci_device_id
*ent
,
140 struct drm_driver
*driver
)
142 struct drm_device
*dev
;
147 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
151 ret
= pci_enable_device(pdev
);
155 pci_set_master(pdev
);
158 dev
->dev
= &pdev
->dev
;
160 dev
->pci_device
= pdev
->device
;
161 dev
->pci_vendor
= pdev
->vendor
;
164 dev
->hose
= pdev
->sysdata
;
167 mutex_lock(&drm_global_mutex
);
169 if ((ret
= drm_fill_in_dev(dev
, ent
, driver
))) {
170 printk(KERN_ERR
"DRM: Fill_in_dev failed.\n");
174 if (drm_core_check_feature(dev
, DRIVER_MODESET
)) {
175 pci_set_drvdata(pdev
, dev
);
176 ret
= drm_get_minor(dev
, &dev
->control
, DRM_MINOR_CONTROL
);
181 if ((ret
= drm_get_minor(dev
, &dev
->primary
, DRM_MINOR_LEGACY
)))
184 if (dev
->driver
->load
) {
185 ret
= dev
->driver
->load(dev
, ent
->driver_data
);
190 /* setup the grouping for the legacy output */
191 if (drm_core_check_feature(dev
, DRIVER_MODESET
)) {
192 ret
= drm_mode_group_init_legacy_group(dev
,
193 &dev
->primary
->mode_group
);
198 list_add_tail(&dev
->driver_item
, &driver
->device_list
);
200 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
201 driver
->name
, driver
->major
, driver
->minor
, driver
->patchlevel
,
202 driver
->date
, pci_name(pdev
), dev
->primary
->index
);
204 mutex_unlock(&drm_global_mutex
);
208 drm_put_minor(&dev
->primary
);
210 if (drm_core_check_feature(dev
, DRIVER_MODESET
))
211 drm_put_minor(&dev
->control
);
213 pci_disable_device(pdev
);
216 mutex_unlock(&drm_global_mutex
);
219 EXPORT_SYMBOL(drm_get_pci_dev
);
222 * PCI device initialization. Called via drm_init at module load time,
224 * \return zero on success or a negative number on failure.
226 * Initializes a drm_device structures,registering the
227 * stubs and initializing the AGP device.
229 * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
230 * after the initialization for driver customization.
232 int drm_pci_init(struct drm_driver
*driver
)
234 struct pci_dev
*pdev
= NULL
;
235 const struct pci_device_id
*pid
;
238 if (driver
->driver_features
& DRIVER_MODESET
)
239 return pci_register_driver(&driver
->pci_driver
);
241 /* If not using KMS, fall back to stealth mode manual scanning. */
242 for (i
= 0; driver
->pci_driver
.id_table
[i
].vendor
!= 0; i
++) {
243 pid
= &driver
->pci_driver
.id_table
[i
];
245 /* Loop around setting up a DRM device for each PCI device
246 * matching our ID and device class. If we had the internal
247 * function that pci_get_subsys and pci_get_class used, we'd
248 * be able to just pass pid in instead of doing a two-stage
253 pci_get_subsys(pid
->vendor
, pid
->device
, pid
->subvendor
,
254 pid
->subdevice
, pdev
)) != NULL
) {
255 if ((pdev
->class & pid
->class_mask
) != pid
->class)
258 /* stealth mode requires a manual probe */
260 drm_get_pci_dev(pdev
, pid
, driver
);
268 int drm_pci_init(struct drm_driver
*driver
)
This page took 0.035373 seconds and 5 git commands to generate.