[deliverable/linux.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 <linux/export.h>
#include <drm/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;
	unsigned long addr;
	size_t sz;

	/* 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((void *)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)
{
	unsigned long addr;
	size_t sz;

	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((void *)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

static int drm_get_pci_domain(struct drm_device *dev)
{
#ifndef __alpha__
	/* For historical reasons, drm_get_pci_domain() is busticated
	 * on most archs and has to remain so for userspace interface
	 * < 1.4, except on alpha which was right from the beginning
	 */
	if (dev->if_version < 0x10004)
		return 0;
#endif /* __alpha__ */

	return pci_domain_nr(dev->pdev->bus);
}

static int drm_pci_get_irq(struct drm_device *dev)
{
	return dev->pdev->irq;
}

static const char *drm_pci_get_name(struct drm_device *dev)
{
	struct pci_driver *pdriver = dev->driver->kdriver.pci;
	return pdriver->name;
}

static int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master)
{
	int len, ret;
	struct pci_driver *pdriver = dev->driver->kdriver.pci;
	master->unique_len = 40;
	master->unique_size = master->unique_len;
	master->unique = kmalloc(master->unique_size, GFP_KERNEL);
	if (master->unique == NULL)
		return -ENOMEM;


	len = snprintf(master->unique, master->unique_len,
		       "pci:%04x:%02x:%02x.%d",
		       drm_get_pci_domain(dev),
		       dev->pdev->bus->number,
		       PCI_SLOT(dev->pdev->devfn),
		       PCI_FUNC(dev->pdev->devfn));

	if (len >= master->unique_len) {
		DRM_ERROR("buffer overflow");
		ret = -EINVAL;
		goto err;
	} else
		master->unique_len = len;

	dev->devname =
		kmalloc(strlen(pdriver->name) +
			master->unique_len + 2, GFP_KERNEL);

	if (dev->devname == NULL) {
		ret = -ENOMEM;
		goto err;
	}

	sprintf(dev->devname, "%s@%s", pdriver->name,
		master->unique);

	return 0;
err:
	return ret;
}

static int drm_pci_set_unique(struct drm_device *dev,
			      struct drm_master *master,
			      struct drm_unique *u)
{
	int domain, bus, slot, func, ret;
	const char *bus_name;

	master->unique_len = u->unique_len;
	master->unique_size = u->unique_len + 1;
	master->unique = kmalloc(master->unique_size, GFP_KERNEL);
	if (!master->unique) {
		ret = -ENOMEM;
		goto err;
	}

	if (copy_from_user(master->unique, u->unique, master->unique_len)) {
		ret = -EFAULT;
		goto err;
	}

	master->unique[master->unique_len] = '\0';

	bus_name = dev->driver->bus->get_name(dev);
	dev->devname = kmalloc(strlen(bus_name) +
			       strlen(master->unique) + 2, GFP_KERNEL);
	if (!dev->devname) {
		ret = -ENOMEM;
		goto err;
	}

	sprintf(dev->devname, "%s@%s", bus_name,
		master->unique);

	/* Return error if the busid submitted doesn't match the device's actual
	 * busid.
	 */
	ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func);
	if (ret != 3) {
		ret = -EINVAL;
		goto err;
	}

	domain = bus >> 8;
	bus &= 0xff;

	if ((domain != drm_get_pci_domain(dev)) ||
	    (bus != dev->pdev->bus->number) ||
	    (slot != PCI_SLOT(dev->pdev->devfn)) ||
	    (func != PCI_FUNC(dev->pdev->devfn))) {
		ret = -EINVAL;
		goto err;
	}
	return 0;
err:
	return ret;
}


static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p)
{
	if ((p->busnum >> 8) != drm_get_pci_domain(dev) ||
	    (p->busnum & 0xff) != dev->pdev->bus->number ||
	    p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn))
		return -EINVAL;

	p->irq = dev->pdev->irq;

	DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
		  p->irq);
	return 0;
}

static void drm_pci_agp_init(struct drm_device *dev)
{
	if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
		if (drm_pci_device_is_agp(dev))
			dev->agp = drm_agp_init(dev);
		if (dev->agp) {
			dev->agp->agp_mtrr = arch_phys_wc_add(
				dev->agp->agp_info.aper_base,
				dev->agp->agp_info.aper_size *
				1024 * 1024);
		}
	}
}

static void drm_pci_agp_destroy(struct drm_device *dev)
{
	if (dev->agp) {
		arch_phys_wc_del(dev->agp->agp_mtrr);
		drm_agp_clear(dev);
		drm_agp_destroy(dev->agp);
		dev->agp = NULL;
	}
}

static struct drm_bus drm_pci_bus = {
	.bus_type = DRIVER_BUS_PCI,
	.get_irq = drm_pci_get_irq,
	.get_name = drm_pci_get_name,
	.set_busid = drm_pci_set_busid,
	.set_unique = drm_pci_set_unique,
	.irq_by_busid = drm_pci_irq_by_busid,
	.agp_init = drm_pci_agp_init,
	.agp_destroy = drm_pci_agp_destroy,
};

/**
 * 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 = drm_dev_alloc(driver, &pdev->dev);
	if (!dev)
		return -ENOMEM;

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

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

	if (drm_core_check_feature(dev, DRIVER_MODESET))
		pci_set_drvdata(pdev, dev);

	ret = drm_dev_register(dev, ent->driver_data);
	if (ret)
		goto err_pci;

	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);

	/* No locking needed since shadow-attach is single-threaded since it may
	 * only be called from the per-driver module init hook. */
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list);

	return 0;

err_pci:
	pci_disable_device(pdev);
err_free:
	drm_dev_free(dev);
	return ret;
}
EXPORT_SYMBOL(drm_get_pci_dev);

/**
 * PCI device initialization. Called direct from modules at 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_driver *pdriver)
{
	struct pci_dev *pdev = NULL;
	const struct pci_device_id *pid;
	int i;

	DRM_DEBUG("\n");

	driver->kdriver.pci = pdriver;
	driver->bus = &drm_pci_bus;

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

	/* If not using KMS, fall back to stealth mode manual scanning. */
	INIT_LIST_HEAD(&driver->legacy_dev_list);
	for (i = 0; pdriver->id_table[i].vendor != 0; i++) {
		pid = &pdriver->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;
}

int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask)
{
	struct pci_dev *root;
	u32 lnkcap, lnkcap2;

	*mask = 0;
	if (!dev->pdev)
		return -EINVAL;

	root = dev->pdev->bus->self;

	/* we've been informed via and serverworks don't make the cut */
	if (root->vendor == PCI_VENDOR_ID_VIA ||
	    root->vendor == PCI_VENDOR_ID_SERVERWORKS)
		return -EINVAL;

	pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap);
	pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2);

	if (lnkcap2) {	/* PCIe r3.0-compliant */
		if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
			*mask |= DRM_PCIE_SPEED_25;
		if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
			*mask |= DRM_PCIE_SPEED_50;
		if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
			*mask |= DRM_PCIE_SPEED_80;
	} else {	/* pre-r3.0 */
		if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
			*mask |= DRM_PCIE_SPEED_25;
		if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
			*mask |= (DRM_PCIE_SPEED_25 | DRM_PCIE_SPEED_50);
	}

	DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2);
	return 0;
}
EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask);

#else

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

#endif

EXPORT_SYMBOL(drm_pci_init);

/*@}*/
void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver)
{
	struct drm_device *dev, *tmp;
	DRM_DEBUG("\n");

	if (driver->driver_features & DRIVER_MODESET) {
		pci_unregister_driver(pdriver);
	} else {
		list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list,
					 legacy_dev_list) {
			drm_put_dev(dev);
			list_del(&dev->legacy_dev_list);
		}
	}
	DRM_INFO("Module unloaded\n");
}
EXPORT_SYMBOL(drm_pci_exit);
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>
2d1a8a48	42	#include <linux/export.h>
760285e7	43	#include <drm/drmP.h>
1da177e4 LT	44
	45	/**********************************************************************/
	46	/** \name PCI memory */
	47	/@{/
	48
	49	/**
	50	* \brief Allocate a PCI consistent memory block, for DMA.
	51	*/
e6be8d9d	52	drm_dma_handle_t drm_pci_alloc(struct drm_device dev, size_t size, size_t align)
1da177e4	53	{
9c8da5eb	54	drm_dma_handle_t *dmah;
ddf19b97 DA	55	unsigned long addr;
ddf19b97 DA	56	size_t sz;
1da177e4 LT	57
	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
	61	*/
	62	if (align > size)
	63	return NULL;
	64
9c8da5eb DA	65	dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL);
	66	if (!dmah)
	67	return NULL;
b5e89ed5	68
9c8da5eb	69	dmah->size = size;
ddf19b97	70	dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL \| __GFP_COMP);
1da177e4	71
9c8da5eb DA	72	if (dmah->vaddr == NULL) {
9c8da5eb DA	73	kfree(dmah);
1da177e4	74	return NULL;
9c8da5eb	75	}
1da177e4	76
9c8da5eb	77	memset(dmah->vaddr, 0, size);
1da177e4	78
ddf19b97 DA	79	/* XXX - Is virt_to_page() legal for consistent mem? */
	80	/* Reserve */
	81	for (addr = (unsigned long)dmah->vaddr, sz = size;
	82	sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
e1e78533	83	SetPageReserved(virt_to_page((void *)addr));
ddf19b97 DA	84	}
ddf19b97 DA	85
9c8da5eb	86	return dmah;
1da177e4	87	}
b5e89ed5	88
1da177e4 LT	89	EXPORT_SYMBOL(drm_pci_alloc);
	90
	91	/**
ddf19b97	92	* \brief Free a PCI consistent memory block without freeing its descriptor.
9c8da5eb DA	93	*
9c8da5eb DA	94	* This function is for internal use in the Linux-specific DRM core code.
1da177e4	95	*/
84b1fd10	96	void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
1da177e4	97	{
ddf19b97 DA	98	unsigned long addr;
ddf19b97 DA	99	size_t sz;
1da177e4	100
9a298b2a	101	if (dmah->vaddr) {
ddf19b97 DA	102	/* XXX - Is virt_to_page() legal for consistent mem? */
	103	/* Unreserve */
	104	for (addr = (unsigned long)dmah->vaddr, sz = dmah->size;
	105	sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
e1e78533	106	ClearPageReserved(virt_to_page((void *)addr));
ddf19b97 DA	107	}
	108	dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr,
	109	dmah->busaddr);
1da177e4	110	}
1da177e4	111	}
9c8da5eb DA	112
	113	/**
	114	* \brief Free a PCI consistent memory block
	115	*/
84b1fd10	116	void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
9c8da5eb DA	117	{
	118	__drm_pci_free(dev, dmah);
	119	kfree(dmah);
	120	}
b5e89ed5	121
1da177e4 LT	122	EXPORT_SYMBOL(drm_pci_free);
1da177e4 LT	123
dcdb1674	124	#ifdef CONFIG_PCI
8410ea3b DA	125
	126	static int drm_get_pci_domain(struct drm_device *dev)
	127	{
	128	#ifndef __alpha__
	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
	132	*/
	133	if (dev->if_version < 0x10004)
	134	return 0;
	135	#endif /* __alpha__ */
	136
	137	return pci_domain_nr(dev->pdev->bus);
	138	}
	139
	140	static int drm_pci_get_irq(struct drm_device *dev)
	141	{
	142	return dev->pdev->irq;
	143	}
	144
	145	static const char drm_pci_get_name(struct drm_device dev)
	146	{
	147	struct pci_driver *pdriver = dev->driver->kdriver.pci;
	148	return pdriver->name;
	149	}
	150
ea9cbb06	151	static int drm_pci_set_busid(struct drm_device dev, struct drm_master master)
8410ea3b DA	152	{
	153	int len, ret;
	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)
	159	return -ENOMEM;
	160
	161
	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));
	168
	169	if (len >= master->unique_len) {
	170	DRM_ERROR("buffer overflow");
	171	ret = -EINVAL;
	172	goto err;
	173	} else
	174	master->unique_len = len;
	175
	176	dev->devname =
	177	kmalloc(strlen(pdriver->name) +
	178	master->unique_len + 2, GFP_KERNEL);
	179
	180	if (dev->devname == NULL) {
	181	ret = -ENOMEM;
	182	goto err;
	183	}
	184
	185	sprintf(dev->devname, "%s@%s", pdriver->name,
	186	master->unique);
	187
	188	return 0;
	189	err:
	190	return ret;
	191	}
	192
ea9cbb06 VS	193	static int drm_pci_set_unique(struct drm_device *dev,
	194	struct drm_master *master,
	195	struct drm_unique *u)
8410ea3b DA	196	{
	197	int domain, bus, slot, func, ret;
	198	const char *bus_name;
	199
	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) {
	204	ret = -ENOMEM;
	205	goto err;
	206	}
	207
	208	if (copy_from_user(master->unique, u->unique, master->unique_len)) {
	209	ret = -EFAULT;
	210	goto err;
	211	}
	212
	213	master->unique[master->unique_len] = '\0';
	214
	215	bus_name = dev->driver->bus->get_name(dev);
	216	dev->devname = kmalloc(strlen(bus_name) +
	217	strlen(master->unique) + 2, GFP_KERNEL);
	218	if (!dev->devname) {
	219	ret = -ENOMEM;
	220	goto err;
	221	}
	222
	223	sprintf(dev->devname, "%s@%s", bus_name,
	224	master->unique);
	225
	226	/* Return error if the busid submitted doesn't match the device's actual
	227	* busid.
	228	*/
	229	ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func);
	230	if (ret != 3) {
	231	ret = -EINVAL;
	232	goto err;
	233	}
	234
	235	domain = bus >> 8;
	236	bus &= 0xff;
	237
	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))) {
	242	ret = -EINVAL;
	243	goto err;
	244	}
	245	return 0;
	246	err:
	247	return ret;
	248	}
	249
	250
45e97ab6	251	static int drm_pci_irq_by_busid(struct drm_device dev, struct drm_irq_busid p)
8410ea3b DA	252	{
	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))
	256	return -EINVAL;
	257
	258	p->irq = dev->pdev->irq;
	259
	260	DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
	261	p->irq);
	262	return 0;
	263	}
	264
8da79ccd	265	static void drm_pci_agp_init(struct drm_device *dev)
8410ea3b	266	{
d9906753	267	if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
8410ea3b DA	268	if (drm_pci_device_is_agp(dev))
8410ea3b DA	269	dev->agp = drm_agp_init(dev);
28185647 DV	270	if (dev->agp) {
	271	dev->agp->agp_mtrr = arch_phys_wc_add(
	272	dev->agp->agp_info.aper_base,
	273	dev->agp->agp_info.aper_size *
	274	1024 * 1024);
8410ea3b DA	275	}
8410ea3b DA	276	}
8410ea3b DA	277	}
8410ea3b DA	278
28ec711c DH	279	static void drm_pci_agp_destroy(struct drm_device *dev)
28ec711c DH	280	{
d9906753	281	if (dev->agp) {
28185647	282	arch_phys_wc_del(dev->agp->agp_mtrr);
28ec711c DH	283	drm_agp_clear(dev);
	284	drm_agp_destroy(dev->agp);
	285	dev->agp = NULL;
	286	}
	287	}
	288
8410ea3b DA	289	static struct drm_bus drm_pci_bus = {
	290	.bus_type = DRIVER_BUS_PCI,
	291	.get_irq = drm_pci_get_irq,
	292	.get_name = drm_pci_get_name,
	293	.set_busid = drm_pci_set_busid,
	294	.set_unique = drm_pci_set_unique,
45e97ab6	295	.irq_by_busid = drm_pci_irq_by_busid,
8410ea3b	296	.agp_init = drm_pci_agp_init,
28ec711c	297	.agp_destroy = drm_pci_agp_destroy,
8410ea3b DA	298	};
8410ea3b DA	299
dcdb1674 JC	300	/**
	301	* Register.
	302	*
	303	* \param pdev - PCI device structure
	304	* \param ent entry from the PCI ID table with device type flags
	305	* \return zero on success or a negative number on failure.
	306	*
	307	* Attempt to gets inter module "drm" information. If we are first
	308	* then register the character device and inter module information.
	309	* Try and register, if we fail to register, backout previous work.
	310	*/
	311	int drm_get_pci_dev(struct pci_dev pdev, const struct pci_device_id ent,
	312	struct drm_driver *driver)
	313	{
	314	struct drm_device *dev;
	315	int ret;
	316
	317	DRM_DEBUG("\n");
	318
1bb72532	319	dev = drm_dev_alloc(driver, &pdev->dev);
dcdb1674 JC	320	if (!dev)
	321	return -ENOMEM;
	322
	323	ret = pci_enable_device(pdev);
	324	if (ret)
c22f0ace	325	goto err_free;
dcdb1674	326
dcdb1674	327	dev->pdev = pdev;
dcdb1674 JC	328	#ifdef __alpha__
	329	dev->hose = pdev->sysdata;
	330	#endif
	331
c22f0ace	332	if (drm_core_check_feature(dev, DRIVER_MODESET))
dcdb1674	333	pci_set_drvdata(pdev, dev);
1793126f	334
c22f0ace DH	335	ret = drm_dev_register(dev, ent->driver_data);
	336	if (ret)
	337	goto err_pci;
dcdb1674 JC	338
	339	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
	340	driver->name, driver->major, driver->minor, driver->patchlevel,
	341	driver->date, pci_name(pdev), dev->primary->index);
	342
b3f2333d DV	343	/* No locking needed since shadow-attach is single-threaded since it may
	344	* only be called from the per-driver module init hook. */
	345	if (!drm_core_check_feature(dev, DRIVER_MODESET))
	346	list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list);
	347
dcdb1674 JC	348	return 0;
dcdb1674 JC	349
c22f0ace	350	err_pci:
dcdb1674	351	pci_disable_device(pdev);
c22f0ace	352	err_free:
0dc8fe59	353	drm_dev_free(dev);
dcdb1674 JC	354	return ret;
	355	}
	356	EXPORT_SYMBOL(drm_get_pci_dev);
	357
	358	/**
8410ea3b	359	* PCI device initialization. Called direct from modules at load time.
dcdb1674 JC	360	*
	361	* \return zero on success or a negative number on failure.
	362	*
	363	* Initializes a drm_device structures,registering the
	364	* stubs and initializing the AGP device.
	365	*
	366	* Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
	367	* after the initialization for driver customization.
	368	*/
8410ea3b	369	int drm_pci_init(struct drm_driver driver, struct pci_driver pdriver)
dcdb1674 JC	370	{
	371	struct pci_dev *pdev = NULL;
	372	const struct pci_device_id *pid;
	373	int i;
	374
8410ea3b DA	375	DRM_DEBUG("\n");
8410ea3b DA	376
8410ea3b DA	377	driver->kdriver.pci = pdriver;
	378	driver->bus = &drm_pci_bus;
	379
dcdb1674	380	if (driver->driver_features & DRIVER_MODESET)
8410ea3b	381	return pci_register_driver(pdriver);
dcdb1674 JC	382
dcdb1674 JC	383	/* If not using KMS, fall back to stealth mode manual scanning. */
b3f2333d	384	INIT_LIST_HEAD(&driver->legacy_dev_list);
8410ea3b DA	385	for (i = 0; pdriver->id_table[i].vendor != 0; i++) {
8410ea3b DA	386	pid = &pdriver->id_table[i];
dcdb1674 JC	387
	388	/* Loop around setting up a DRM device for each PCI device
	389	* matching our ID and device class. If we had the internal
	390	* function that pci_get_subsys and pci_get_class used, we'd
	391	* be able to just pass pid in instead of doing a two-stage
	392	* thing.
	393	*/
	394	pdev = NULL;
	395	while ((pdev =
	396	pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
	397	pid->subdevice, pdev)) != NULL) {
	398	if ((pdev->class & pid->class_mask) != pid->class)
	399	continue;
	400
	401	/* stealth mode requires a manual probe */
	402	pci_dev_get(pdev);
	403	drm_get_pci_dev(pdev, pid, driver);
	404	}
	405	}
	406	return 0;
	407	}
	408
f4297784 DA	409	int drm_pcie_get_speed_cap_mask(struct drm_device dev, u32 mask)
	410	{
	411	struct pci_dev *root;
dd66cc2e	412	u32 lnkcap, lnkcap2;
f4297784 DA	413
	414	*mask = 0;
	415	if (!dev->pdev)
	416	return -EINVAL;
	417
f4297784 DA	418	root = dev->pdev->bus->self;
f4297784 DA	419
f4297784 DA	420	/* we've been informed via and serverworks don't make the cut */
	421	if (root->vendor == PCI_VENDOR_ID_VIA \|\|
	422	root->vendor == PCI_VENDOR_ID_SERVERWORKS)
	423	return -EINVAL;
	424
dd66cc2e BH	425	pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap);
dd66cc2e BH	426	pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2);
f4297784	427
dd66cc2e	428	if (lnkcap2) { /* PCIe r3.0-compliant */
f4297784 DA	429	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
	430	*mask \|= DRM_PCIE_SPEED_25;
	431	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
	432	*mask \|= DRM_PCIE_SPEED_50;
	433	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
	434	*mask \|= DRM_PCIE_SPEED_80;
dd66cc2e	435	} else { /* pre-r3.0 */
9fe0423e	436	if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
f4297784	437	*mask \|= DRM_PCIE_SPEED_25;
9fe0423e	438	if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
f8acf6f4	439	*mask \|= (DRM_PCIE_SPEED_25 \| DRM_PCIE_SPEED_50);
f4297784 DA	440	}
	441
	442	DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2);
	443	return 0;
	444	}
	445	EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask);
93711d8b BH	446
	447	#else
	448
	449	int drm_pci_init(struct drm_driver driver, struct pci_driver pdriver)
	450	{
	451	return -1;
	452	}
	453
	454	#endif
	455
	456	EXPORT_SYMBOL(drm_pci_init);
	457
	458	/@}/
	459	void drm_pci_exit(struct drm_driver driver, struct pci_driver pdriver)
	460	{
	461	struct drm_device dev, tmp;
	462	DRM_DEBUG("\n");
	463
	464	if (driver->driver_features & DRIVER_MODESET) {
	465	pci_unregister_driver(pdriver);
	466	} else {
b3f2333d DV	467	list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list,
b3f2333d DV	468	legacy_dev_list) {
93711d8b	469	drm_put_dev(dev);
b3f2333d DV	470	list_del(&dev->legacy_dev_list);
b3f2333d DV	471	}
93711d8b BH	472	}
	473	DRM_INFO("Module unloaded\n");
	474	}
	475	EXPORT_SYMBOL(drm_pci_exit);