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 if ((ret = drm_fill_in_dev(dev, ent, driver))) {
168 printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
172 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
173 pci_set_drvdata(pdev, dev);
174 ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL);
179 if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY)))
182 if (dev->driver->load) {
183 ret = dev->driver->load(dev, ent->driver_data);
188 /* setup the grouping for the legacy output */
189 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
190 ret = drm_mode_group_init_legacy_group(dev,
191 &dev->primary->mode_group);
196 list_add_tail(&dev->driver_item, &driver->device_list);
198 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
199 driver->name, driver->major, driver->minor, driver->patchlevel,
200 driver->date, pci_name(pdev), dev->primary->index);
205 drm_put_minor(&dev->primary);
207 if (drm_core_check_feature(dev, DRIVER_MODESET))
208 drm_put_minor(&dev->control);
210 pci_disable_device(pdev);
215 EXPORT_SYMBOL(drm_get_pci_dev);
218 * PCI device initialization. Called via drm_init at module load time,
220 * \return zero on success or a negative number on failure.
222 * Initializes a drm_device structures,registering the
223 * stubs and initializing the AGP device.
225 * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
226 * after the initialization for driver customization.
228 int drm_pci_init(struct drm_driver *driver)
230 struct pci_dev *pdev = NULL;
231 const struct pci_device_id *pid;
234 if (driver->driver_features & DRIVER_MODESET)
235 return pci_register_driver(&driver->pci_driver);
237 /* If not using KMS, fall back to stealth mode manual scanning. */
238 for (i = 0; driver->pci_driver.id_table[i].vendor != 0; i++) {
239 pid = &driver->pci_driver.id_table[i];
241 /* Loop around setting up a DRM device for each PCI device
242 * matching our ID and device class. If we had the internal
243 * function that pci_get_subsys and pci_get_class used, we'd
244 * be able to just pass pid in instead of doing a two-stage
249 pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
250 pid->subdevice, pdev)) != NULL) {
251 if ((pdev->class & pid->class_mask) != pid->class)
254 /* stealth mode requires a manual probe */
256 drm_get_pci_dev(pdev, pid, driver);
264 int drm_pci_init(struct drm_driver *driver)