[mirror_ubuntu-bionic-kernel.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_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);

	mutex_lock(&drm_global_mutex);
	drm_pci_agp_init(dev);
	mutex_unlock(&drm_global_mutex);

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

	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_agp:
	mutex_lock(&drm_global_mutex);
	drm_pci_agp_destroy(dev);
	mutex_unlock(&drm_global_mutex);
	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,
28ec711c	296	.agp_destroy = drm_pci_agp_destroy,
8410ea3b DA	297	};
8410ea3b DA	298
dcdb1674 JC	299	/**
	300	* Register.
	301	*
	302	* \param pdev - PCI device structure
	303	* \param ent entry from the PCI ID table with device type flags
	304	* \return zero on success or a negative number on failure.
	305	*
	306	* Attempt to gets inter module "drm" information. If we are first
	307	* then register the character device and inter module information.
	308	* Try and register, if we fail to register, backout previous work.
	309	*/
	310	int drm_get_pci_dev(struct pci_dev pdev, const struct pci_device_id ent,
	311	struct drm_driver *driver)
	312	{
	313	struct drm_device *dev;
	314	int ret;
	315
	316	DRM_DEBUG("\n");
	317
1bb72532	318	dev = drm_dev_alloc(driver, &pdev->dev);
dcdb1674 JC	319	if (!dev)
	320	return -ENOMEM;
	321
	322	ret = pci_enable_device(pdev);
	323	if (ret)
c22f0ace	324	goto err_free;
dcdb1674	325
dcdb1674	326	dev->pdev = pdev;
dcdb1674 JC	327	#ifdef __alpha__
	328	dev->hose = pdev->sysdata;
	329	#endif
	330
c22f0ace	331	if (drm_core_check_feature(dev, DRIVER_MODESET))
dcdb1674	332	pci_set_drvdata(pdev, dev);
1793126f	333
2c695fa0 DV	334	mutex_lock(&drm_global_mutex);
	335	drm_pci_agp_init(dev);
	336	mutex_unlock(&drm_global_mutex);
	337
c22f0ace DH	338	ret = drm_dev_register(dev, ent->driver_data);
c22f0ace DH	339	if (ret)
2c695fa0	340	goto err_agp;
dcdb1674 JC	341
	342	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
	343	driver->name, driver->major, driver->minor, driver->patchlevel,
	344	driver->date, pci_name(pdev), dev->primary->index);
	345
b3f2333d DV	346	/* No locking needed since shadow-attach is single-threaded since it may
	347	* only be called from the per-driver module init hook. */
	348	if (!drm_core_check_feature(dev, DRIVER_MODESET))
	349	list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list);
	350
dcdb1674 JC	351	return 0;
dcdb1674 JC	352
2c695fa0 DV	353	err_agp:
	354	mutex_lock(&drm_global_mutex);
	355	drm_pci_agp_destroy(dev);
	356	mutex_unlock(&drm_global_mutex);
dcdb1674	357	pci_disable_device(pdev);
c22f0ace	358	err_free:
0dc8fe59	359	drm_dev_free(dev);
dcdb1674 JC	360	return ret;
	361	}
	362	EXPORT_SYMBOL(drm_get_pci_dev);
	363
	364	/**
8410ea3b	365	* PCI device initialization. Called direct from modules at load time.
dcdb1674 JC	366	*
	367	* \return zero on success or a negative number on failure.
	368	*
	369	* Initializes a drm_device structures,registering the
	370	* stubs and initializing the AGP device.
	371	*
	372	* Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
	373	* after the initialization for driver customization.
	374	*/
8410ea3b	375	int drm_pci_init(struct drm_driver driver, struct pci_driver pdriver)
dcdb1674 JC	376	{
	377	struct pci_dev *pdev = NULL;
	378	const struct pci_device_id *pid;
	379	int i;
	380
8410ea3b DA	381	DRM_DEBUG("\n");
8410ea3b DA	382
8410ea3b DA	383	driver->kdriver.pci = pdriver;
	384	driver->bus = &drm_pci_bus;
	385
dcdb1674	386	if (driver->driver_features & DRIVER_MODESET)
8410ea3b	387	return pci_register_driver(pdriver);
dcdb1674 JC	388
dcdb1674 JC	389	/* If not using KMS, fall back to stealth mode manual scanning. */
b3f2333d	390	INIT_LIST_HEAD(&driver->legacy_dev_list);
8410ea3b DA	391	for (i = 0; pdriver->id_table[i].vendor != 0; i++) {
8410ea3b DA	392	pid = &pdriver->id_table[i];
dcdb1674 JC	393
	394	/* Loop around setting up a DRM device for each PCI device
	395	* matching our ID and device class. If we had the internal
	396	* function that pci_get_subsys and pci_get_class used, we'd
	397	* be able to just pass pid in instead of doing a two-stage
	398	* thing.
	399	*/
	400	pdev = NULL;
	401	while ((pdev =
	402	pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
	403	pid->subdevice, pdev)) != NULL) {
	404	if ((pdev->class & pid->class_mask) != pid->class)
	405	continue;
	406
	407	/* stealth mode requires a manual probe */
	408	pci_dev_get(pdev);
	409	drm_get_pci_dev(pdev, pid, driver);
	410	}
	411	}
	412	return 0;
	413	}
	414
f4297784 DA	415	int drm_pcie_get_speed_cap_mask(struct drm_device dev, u32 mask)
	416	{
	417	struct pci_dev *root;
dd66cc2e	418	u32 lnkcap, lnkcap2;
f4297784 DA	419
	420	*mask = 0;
	421	if (!dev->pdev)
	422	return -EINVAL;
	423
f4297784 DA	424	root = dev->pdev->bus->self;
f4297784 DA	425
f4297784 DA	426	/* we've been informed via and serverworks don't make the cut */
	427	if (root->vendor == PCI_VENDOR_ID_VIA \|\|
	428	root->vendor == PCI_VENDOR_ID_SERVERWORKS)
	429	return -EINVAL;
	430
dd66cc2e BH	431	pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap);
dd66cc2e BH	432	pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2);
f4297784	433
dd66cc2e	434	if (lnkcap2) { /* PCIe r3.0-compliant */
f4297784 DA	435	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
	436	*mask \|= DRM_PCIE_SPEED_25;
	437	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
	438	*mask \|= DRM_PCIE_SPEED_50;
	439	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
	440	*mask \|= DRM_PCIE_SPEED_80;
dd66cc2e	441	} else { /* pre-r3.0 */
9fe0423e	442	if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
f4297784	443	*mask \|= DRM_PCIE_SPEED_25;
9fe0423e	444	if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
f8acf6f4	445	*mask \|= (DRM_PCIE_SPEED_25 \| DRM_PCIE_SPEED_50);
f4297784 DA	446	}
	447
	448	DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2);
	449	return 0;
	450	}
	451	EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask);
93711d8b BH	452
	453	#else
	454
	455	int drm_pci_init(struct drm_driver driver, struct pci_driver pdriver)
	456	{
	457	return -1;
	458	}
	459
	460	#endif
	461
	462	EXPORT_SYMBOL(drm_pci_init);
	463
	464	/@}/
	465	void drm_pci_exit(struct drm_driver driver, struct pci_driver pdriver)
	466	{
	467	struct drm_device dev, tmp;
	468	DRM_DEBUG("\n");
	469
	470	if (driver->driver_features & DRIVER_MODESET) {
	471	pci_unregister_driver(pdriver);
	472	} else {
b3f2333d DV	473	list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list,
b3f2333d DV	474	legacy_dev_list) {
93711d8b	475	drm_put_dev(dev);
b3f2333d DV	476	list_del(&dev->legacy_dev_list);
b3f2333d DV	477	}
93711d8b BH	478	}
	479	DRM_INFO("Module unloaded\n");
	480	}
	481	EXPORT_SYMBOL(drm_pci_exit);