[net-next-2.6.git] / drivers / gpu / drm / drm_pci.c

/* drm_pci.h -- PCI DMA memory management wrappers for DRM -*- linux-c -*- */
/**
 * \file drm_pci.c
 * \brief Functions and ioctls to manage PCI memory
 *
 * \warning These interfaces aren't stable yet.
 *
 * \todo Implement the remaining ioctl's for the PCI pools.
 * \todo The wrappers here are so thin that they would be better off inlined..
 *
 * \author José Fonseca <jrfonseca@tungstengraphics.com>
 * \author Leif Delgass <ldelgass@retinalburn.net>
 */

/*
 * Copyright 2003 José Fonseca.
 * Copyright 2003 Leif Delgass.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include "drmP.h"

/**********************************************************************/
/** \name PCI memory */
/*@{*/

/**
 * \brief Allocate a PCI consistent memory block, for DMA.
 */
drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align)
{
	drm_dma_handle_t *dmah;
#if 1
	unsigned long addr;
	size_t sz;
#endif

	/* pci_alloc_consistent only guarantees alignment to the smallest
	 * PAGE_SIZE order which is greater than or equal to the requested size.
	 * Return NULL here for now to make sure nobody tries for larger alignment
	 */
	if (align > size)
		return NULL;

	dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL);
	if (!dmah)
		return NULL;

	dmah->size = size;
	dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP);

	if (dmah->vaddr == NULL) {
		kfree(dmah);
		return NULL;
	}

	memset(dmah->vaddr, 0, size);

	/* XXX - Is virt_to_page() legal for consistent mem? */
	/* Reserve */
	for (addr = (unsigned long)dmah->vaddr, sz = size;
	     sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
		SetPageReserved(virt_to_page(addr));
	}

	return dmah;
}

EXPORT_SYMBOL(drm_pci_alloc);

/**
 * \brief Free a PCI consistent memory block without freeing its descriptor.
 *
 * This function is for internal use in the Linux-specific DRM core code.
 */
void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
{
#if 1
	unsigned long addr;
	size_t sz;
#endif

	if (dmah->vaddr) {
		/* XXX - Is virt_to_page() legal for consistent mem? */
		/* Unreserve */
		for (addr = (unsigned long)dmah->vaddr, sz = dmah->size;
		     sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
			ClearPageReserved(virt_to_page(addr));
		}
		dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr,
				  dmah->busaddr);
	}
}

/**
 * \brief Free a PCI consistent memory block
 */
void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
{
	__drm_pci_free(dev, dmah);
	kfree(dmah);
}

EXPORT_SYMBOL(drm_pci_free);

#ifdef CONFIG_PCI
/**
 * Register.
 *
 * \param pdev - PCI device structure
 * \param ent entry from the PCI ID table with device type flags
 * \return zero on success or a negative number on failure.
 *
 * Attempt to gets inter module "drm" information. If we are first
 * then register the character device and inter module information.
 * Try and register, if we fail to register, backout previous work.
 */
int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
		    struct drm_driver *driver)
{
	struct drm_device *dev;
	int ret;

	DRM_DEBUG("\n");

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	ret = pci_enable_device(pdev);
	if (ret)
		goto err_g1;

	pci_set_master(pdev);

	dev->pdev = pdev;
	dev->dev = &pdev->dev;

	dev->pci_device = pdev->device;
	dev->pci_vendor = pdev->vendor;

#ifdef __alpha__
	dev->hose = pdev->sysdata;
#endif

	mutex_lock(&drm_global_mutex);

	if ((ret = drm_fill_in_dev(dev, ent, driver))) {
		printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
		goto err_g2;
	}

	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		pci_set_drvdata(pdev, dev);
		ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL);
		if (ret)
			goto err_g2;
	}

	if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY)))
		goto err_g3;

	if (dev->driver->load) {
		ret = dev->driver->load(dev, ent->driver_data);
		if (ret)
			goto err_g4;
	}

	/* setup the grouping for the legacy output */
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		ret = drm_mode_group_init_legacy_group(dev,
						&dev->primary->mode_group);
		if (ret)
			goto err_g4;
	}

	list_add_tail(&dev->driver_item, &driver->device_list);

	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
		 driver->name, driver->major, driver->minor, driver->patchlevel,
		 driver->date, pci_name(pdev), dev->primary->index);

	mutex_unlock(&drm_global_mutex);
	return 0;

err_g4:
	drm_put_minor(&dev->primary);
err_g3:
	if (drm_core_check_feature(dev, DRIVER_MODESET))
		drm_put_minor(&dev->control);
err_g2:
	pci_disable_device(pdev);
err_g1:
	kfree(dev);
	mutex_unlock(&drm_global_mutex);
	return ret;
}
EXPORT_SYMBOL(drm_get_pci_dev);

/**
 * PCI device initialization. Called via drm_init at module load time,
 *
 * \return zero on success or a negative number on failure.
 *
 * Initializes a drm_device structures,registering the
 * stubs and initializing the AGP device.
 *
 * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
 * after the initialization for driver customization.
 */
int drm_pci_init(struct drm_driver *driver)
{
	struct pci_dev *pdev = NULL;
	const struct pci_device_id *pid;
	int i;

	if (driver->driver_features & DRIVER_MODESET)
		return pci_register_driver(&driver->pci_driver);

	/* If not using KMS, fall back to stealth mode manual scanning. */
	for (i = 0; driver->pci_driver.id_table[i].vendor != 0; i++) {
		pid = &driver->pci_driver.id_table[i];

		/* Loop around setting up a DRM device for each PCI device
		 * matching our ID and device class.  If we had the internal
		 * function that pci_get_subsys and pci_get_class used, we'd
		 * be able to just pass pid in instead of doing a two-stage
		 * thing.
		 */
		pdev = NULL;
		while ((pdev =
			pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
				       pid->subdevice, pdev)) != NULL) {
			if ((pdev->class & pid->class_mask) != pid->class)
				continue;

			/* stealth mode requires a manual probe */
			pci_dev_get(pdev);
			drm_get_pci_dev(pdev, pid, driver);
		}
	}
	return 0;
}

#else

int drm_pci_init(struct drm_driver *driver)
{
	return -1;
}

#endif
/*@}*/
Commit	Line	Data
1da177e4 LT	1	/* drm_pci.h -- PCI DMA memory management wrappers for DRM -- linux-c -- */
	2	/**
	3	* \file drm_pci.c
	4	* \brief Functions and ioctls to manage PCI memory
	5	*
	6	* \warning These interfaces aren't stable yet.
	7	*
	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..
	10	*
96de0e25	11	* \author José Fonseca <jrfonseca@tungstengraphics.com>
1da177e4 LT	12	* \author Leif Delgass <ldelgass@retinalburn.net>
	13	*/
	14
	15	/*
96de0e25	16	* Copyright 2003 José Fonseca.
1da177e4 LT	17	* Copyright 2003 Leif Delgass.
	18	* All Rights Reserved.
	19	*
	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:
	26	*
	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
	29	* Software.
	30	*
	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.
	37	*/
	38
	39	#include <linux/pci.h>
5a0e3ad6	40	#include <linux/slab.h>
195b3a2d	41	#include <linux/dma-mapping.h>
1da177e4 LT	42	#include "drmP.h"
	43
	44	/**********************************************************************/
	45	/** \name PCI memory */
	46	/@{/
	47
	48	/**
	49	* \brief Allocate a PCI consistent memory block, for DMA.
	50	*/
e6be8d9d	51	drm_dma_handle_t drm_pci_alloc(struct drm_device dev, size_t size, size_t align)
1da177e4	52	{
9c8da5eb	53	drm_dma_handle_t *dmah;
ddf19b97 DA	54	#if 1
	55	unsigned long addr;
	56	size_t sz;
	57	#endif
1da177e4 LT	58
	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
	62	*/
	63	if (align > size)
	64	return NULL;
	65
9c8da5eb DA	66	dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL);
	67	if (!dmah)
	68	return NULL;
b5e89ed5	69
9c8da5eb	70	dmah->size = size;
ddf19b97	71	dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL \| __GFP_COMP);
1da177e4	72
9c8da5eb DA	73	if (dmah->vaddr == NULL) {
9c8da5eb DA	74	kfree(dmah);
1da177e4	75	return NULL;
9c8da5eb	76	}
1da177e4	77
9c8da5eb	78	memset(dmah->vaddr, 0, size);
1da177e4	79
ddf19b97 DA	80	/* XXX - Is virt_to_page() legal for consistent mem? */
	81	/* Reserve */
	82	for (addr = (unsigned long)dmah->vaddr, sz = size;
	83	sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
	84	SetPageReserved(virt_to_page(addr));
	85	}
	86
9c8da5eb	87	return dmah;
1da177e4	88	}
b5e89ed5	89
1da177e4 LT	90	EXPORT_SYMBOL(drm_pci_alloc);
	91
	92	/**
ddf19b97	93	* \brief Free a PCI consistent memory block without freeing its descriptor.
9c8da5eb DA	94	*
9c8da5eb DA	95	* This function is for internal use in the Linux-specific DRM core code.
1da177e4	96	*/
84b1fd10	97	void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
1da177e4	98	{
ddf19b97 DA	99	#if 1
	100	unsigned long addr;
	101	size_t sz;
	102	#endif
1da177e4	103
9a298b2a	104	if (dmah->vaddr) {
ddf19b97 DA	105	/* XXX - Is virt_to_page() legal for consistent mem? */
	106	/* Unreserve */
	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));
	110	}
	111	dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr,
	112	dmah->busaddr);
1da177e4	113	}
1da177e4	114	}
9c8da5eb DA	115
	116	/**
	117	* \brief Free a PCI consistent memory block
	118	*/
84b1fd10	119	void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
9c8da5eb DA	120	{
	121	__drm_pci_free(dev, dmah);
	122	kfree(dmah);
	123	}
b5e89ed5	124
1da177e4 LT	125	EXPORT_SYMBOL(drm_pci_free);
1da177e4 LT	126
dcdb1674 JC	127	#ifdef CONFIG_PCI
	128	/**
	129	* Register.
	130	*
	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.
	134	*
	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.
	138	*/
	139	int drm_get_pci_dev(struct pci_dev pdev, const struct pci_device_id ent,
	140	struct drm_driver *driver)
	141	{
	142	struct drm_device *dev;
	143	int ret;
	144
	145	DRM_DEBUG("\n");
	146
	147	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	148	if (!dev)
	149	return -ENOMEM;
	150
	151	ret = pci_enable_device(pdev);
	152	if (ret)
	153	goto err_g1;
	154
	155	pci_set_master(pdev);
	156
	157	dev->pdev = pdev;
	158	dev->dev = &pdev->dev;
	159
	160	dev->pci_device = pdev->device;
	161	dev->pci_vendor = pdev->vendor;
	162
	163	#ifdef __alpha__
	164	dev->hose = pdev->sysdata;
	165	#endif
	166
b64c115e DA	167	mutex_lock(&drm_global_mutex);
b64c115e DA	168
dcdb1674 JC	169	if ((ret = drm_fill_in_dev(dev, ent, driver))) {
	170	printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
	171	goto err_g2;
	172	}
	173
	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);
	177	if (ret)
	178	goto err_g2;
	179	}
	180
	181	if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY)))
	182	goto err_g3;
	183
	184	if (dev->driver->load) {
	185	ret = dev->driver->load(dev, ent->driver_data);
	186	if (ret)
	187	goto err_g4;
	188	}
	189
	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);
	194	if (ret)
	195	goto err_g4;
	196	}
	197
	198	list_add_tail(&dev->driver_item, &driver->device_list);
	199
	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);
	203
b64c115e	204	mutex_unlock(&drm_global_mutex);
dcdb1674 JC	205	return 0;
	206
	207	err_g4:
	208	drm_put_minor(&dev->primary);
	209	err_g3:
	210	if (drm_core_check_feature(dev, DRIVER_MODESET))
	211	drm_put_minor(&dev->control);
	212	err_g2:
	213	pci_disable_device(pdev);
	214	err_g1:
	215	kfree(dev);
b64c115e	216	mutex_unlock(&drm_global_mutex);
dcdb1674 JC	217	return ret;
	218	}
	219	EXPORT_SYMBOL(drm_get_pci_dev);
	220
	221	/**
	222	* PCI device initialization. Called via drm_init at module load time,
	223	*
	224	* \return zero on success or a negative number on failure.
	225	*
	226	* Initializes a drm_device structures,registering the
	227	* stubs and initializing the AGP device.
	228	*
	229	* Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
	230	* after the initialization for driver customization.
	231	*/
	232	int drm_pci_init(struct drm_driver *driver)
	233	{
	234	struct pci_dev *pdev = NULL;
	235	const struct pci_device_id *pid;
	236	int i;
	237
	238	if (driver->driver_features & DRIVER_MODESET)
	239	return pci_register_driver(&driver->pci_driver);
	240
	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];
	244
	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
	249	* thing.
	250	*/
	251	pdev = NULL;
	252	while ((pdev =
	253	pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
	254	pid->subdevice, pdev)) != NULL) {
	255	if ((pdev->class & pid->class_mask) != pid->class)
	256	continue;
	257
	258	/* stealth mode requires a manual probe */
	259	pci_dev_get(pdev);
	260	drm_get_pci_dev(pdev, pid, driver);
	261	}
	262	}
	263	return 0;
	264	}
	265
	266	#else
	267
	268	int drm_pci_init(struct drm_driver *driver)
	269	{
	270	return -1;
	271	}
	272
	273	#endif
1da177e4	274	/@}/