[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(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(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 int drm_pci_agp_init(struct drm_device *dev)
{
	if (drm_core_has_AGP(dev)) {
		if (drm_pci_device_is_agp(dev))
			dev->agp = drm_agp_init(dev);
		if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP)
		    && (dev->agp == NULL)) {
			DRM_ERROR("Cannot initialize the agpgart module.\n");
			return -EINVAL;
		}
		if (drm_core_has_MTRR(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);
		}
	}
	return 0;
}

static void drm_pci_agp_destroy(struct drm_device *dev)
{
	if (drm_core_has_AGP(dev) && dev->agp) {
		if (drm_core_has_MTRR(dev))
			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 = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

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

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

	INIT_LIST_HEAD(&driver->device_list);
	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. */
	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->device_list, driver_item)
			drm_put_dev(dev);
	}
	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) {
	83	SetPageReserved(virt_to_page(addr));
	84	}
	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) {
	106	ClearPageReserved(virt_to_page(addr));
	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
ea9cbb06	265	static int drm_pci_agp_init(struct drm_device *dev)
8410ea3b DA	266	{
	267	if (drm_core_has_AGP(dev)) {
	268	if (drm_pci_device_is_agp(dev))
	269	dev->agp = drm_agp_init(dev);
	270	if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP)
	271	&& (dev->agp == NULL)) {
	272	DRM_ERROR("Cannot initialize the agpgart module.\n");
	273	return -EINVAL;
	274	}
	275	if (drm_core_has_MTRR(dev)) {
	276	if (dev->agp)
f435046d AL	277	dev->agp->agp_mtrr = arch_phys_wc_add(
	278	dev->agp->agp_info.aper_base,
	279	dev->agp->agp_info.aper_size *
	280	1024 * 1024);
8410ea3b DA	281	}
	282	}
	283	return 0;
	284	}
	285
28ec711c DH	286	static void drm_pci_agp_destroy(struct drm_device *dev)
	287	{
	288	if (drm_core_has_AGP(dev) && dev->agp) {
	289	if (drm_core_has_MTRR(dev))
	290	arch_phys_wc_del(dev->agp->agp_mtrr);
	291	drm_agp_clear(dev);
	292	drm_agp_destroy(dev->agp);
	293	dev->agp = NULL;
	294	}
	295	}
	296
8410ea3b DA	297	static struct drm_bus drm_pci_bus = {
	298	.bus_type = DRIVER_BUS_PCI,
	299	.get_irq = drm_pci_get_irq,
	300	.get_name = drm_pci_get_name,
	301	.set_busid = drm_pci_set_busid,
	302	.set_unique = drm_pci_set_unique,
45e97ab6	303	.irq_by_busid = drm_pci_irq_by_busid,
8410ea3b	304	.agp_init = drm_pci_agp_init,
28ec711c	305	.agp_destroy = drm_pci_agp_destroy,
8410ea3b DA	306	};
8410ea3b DA	307
dcdb1674 JC	308	/**
	309	* Register.
	310	*
	311	* \param pdev - PCI device structure
	312	* \param ent entry from the PCI ID table with device type flags
	313	* \return zero on success or a negative number on failure.
	314	*
	315	* Attempt to gets inter module "drm" information. If we are first
	316	* then register the character device and inter module information.
	317	* Try and register, if we fail to register, backout previous work.
	318	*/
	319	int drm_get_pci_dev(struct pci_dev pdev, const struct pci_device_id ent,
	320	struct drm_driver *driver)
	321	{
	322	struct drm_device *dev;
	323	int ret;
	324
	325	DRM_DEBUG("\n");
	326
	327	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	328	if (!dev)
	329	return -ENOMEM;
	330
	331	ret = pci_enable_device(pdev);
	332	if (ret)
	333	goto err_g1;
	334
dcdb1674 JC	335	dev->pdev = pdev;
	336	dev->dev = &pdev->dev;
	337
	338	dev->pci_device = pdev->device;
	339	dev->pci_vendor = pdev->vendor;
	340
	341	#ifdef __alpha__
	342	dev->hose = pdev->sysdata;
	343	#endif
	344
b64c115e DA	345	mutex_lock(&drm_global_mutex);
b64c115e DA	346
dcdb1674 JC	347	if ((ret = drm_fill_in_dev(dev, ent, driver))) {
	348	printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
	349	goto err_g2;
	350	}
	351
	352	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
	353	pci_set_drvdata(pdev, dev);
	354	ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL);
	355	if (ret)
	356	goto err_g2;
	357	}
	358
	359	if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY)))
	360	goto err_g3;
	361
	362	if (dev->driver->load) {
	363	ret = dev->driver->load(dev, ent->driver_data);
	364	if (ret)
	365	goto err_g4;
	366	}
	367
	368	/* setup the grouping for the legacy output */
	369	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
	370	ret = drm_mode_group_init_legacy_group(dev,
	371	&dev->primary->mode_group);
	372	if (ret)
	373	goto err_g4;
	374	}
	375
	376	list_add_tail(&dev->driver_item, &driver->device_list);
	377
	378	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
	379	driver->name, driver->major, driver->minor, driver->patchlevel,
	380	driver->date, pci_name(pdev), dev->primary->index);
	381
b64c115e	382	mutex_unlock(&drm_global_mutex);
dcdb1674 JC	383	return 0;
	384
	385	err_g4:
	386	drm_put_minor(&dev->primary);
	387	err_g3:
	388	if (drm_core_check_feature(dev, DRIVER_MODESET))
	389	drm_put_minor(&dev->control);
	390	err_g2:
	391	pci_disable_device(pdev);
	392	err_g1:
	393	kfree(dev);
b64c115e	394	mutex_unlock(&drm_global_mutex);
dcdb1674 JC	395	return ret;
	396	}
	397	EXPORT_SYMBOL(drm_get_pci_dev);
	398
	399	/**
8410ea3b	400	* PCI device initialization. Called direct from modules at load time.
dcdb1674 JC	401	*
	402	* \return zero on success or a negative number on failure.
	403	*
	404	* Initializes a drm_device structures,registering the
	405	* stubs and initializing the AGP device.
	406	*
	407	* Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
	408	* after the initialization for driver customization.
	409	*/
8410ea3b	410	int drm_pci_init(struct drm_driver driver, struct pci_driver pdriver)
dcdb1674 JC	411	{
	412	struct pci_dev *pdev = NULL;
	413	const struct pci_device_id *pid;
	414	int i;
	415
8410ea3b DA	416	DRM_DEBUG("\n");
	417
	418	INIT_LIST_HEAD(&driver->device_list);
	419	driver->kdriver.pci = pdriver;
	420	driver->bus = &drm_pci_bus;
	421
dcdb1674	422	if (driver->driver_features & DRIVER_MODESET)
8410ea3b	423	return pci_register_driver(pdriver);
dcdb1674 JC	424
dcdb1674 JC	425	/* If not using KMS, fall back to stealth mode manual scanning. */
8410ea3b DA	426	for (i = 0; pdriver->id_table[i].vendor != 0; i++) {
8410ea3b DA	427	pid = &pdriver->id_table[i];
dcdb1674 JC	428
	429	/* Loop around setting up a DRM device for each PCI device
	430	* matching our ID and device class. If we had the internal
	431	* function that pci_get_subsys and pci_get_class used, we'd
	432	* be able to just pass pid in instead of doing a two-stage
	433	* thing.
	434	*/
	435	pdev = NULL;
	436	while ((pdev =
	437	pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
	438	pid->subdevice, pdev)) != NULL) {
	439	if ((pdev->class & pid->class_mask) != pid->class)
	440	continue;
	441
	442	/* stealth mode requires a manual probe */
	443	pci_dev_get(pdev);
	444	drm_get_pci_dev(pdev, pid, driver);
	445	}
	446	}
	447	return 0;
	448	}
	449
f4297784 DA	450	int drm_pcie_get_speed_cap_mask(struct drm_device dev, u32 mask)
	451	{
	452	struct pci_dev *root;
dd66cc2e	453	u32 lnkcap, lnkcap2;
f4297784 DA	454
	455	*mask = 0;
	456	if (!dev->pdev)
	457	return -EINVAL;
	458
f4297784 DA	459	root = dev->pdev->bus->self;
f4297784 DA	460
f4297784 DA	461	/* we've been informed via and serverworks don't make the cut */
	462	if (root->vendor == PCI_VENDOR_ID_VIA \|\|
	463	root->vendor == PCI_VENDOR_ID_SERVERWORKS)
	464	return -EINVAL;
	465
dd66cc2e BH	466	pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap);
dd66cc2e BH	467	pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2);
f4297784	468
dd66cc2e	469	if (lnkcap2) { /* PCIe r3.0-compliant */
f4297784 DA	470	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
	471	*mask \|= DRM_PCIE_SPEED_25;
	472	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
	473	*mask \|= DRM_PCIE_SPEED_50;
	474	if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
	475	*mask \|= DRM_PCIE_SPEED_80;
dd66cc2e	476	} else { /* pre-r3.0 */
9fe0423e	477	if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
f4297784	478	*mask \|= DRM_PCIE_SPEED_25;
9fe0423e	479	if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
f8acf6f4	480	*mask \|= (DRM_PCIE_SPEED_25 \| DRM_PCIE_SPEED_50);
f4297784 DA	481	}
	482
	483	DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2);
	484	return 0;
	485	}
	486	EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask);
93711d8b BH	487
	488	#else
	489
	490	int drm_pci_init(struct drm_driver driver, struct pci_driver pdriver)
	491	{
	492	return -1;
	493	}
	494
	495	#endif
	496
	497	EXPORT_SYMBOL(drm_pci_init);
	498
	499	/@}/
	500	void drm_pci_exit(struct drm_driver driver, struct pci_driver pdriver)
	501	{
	502	struct drm_device dev, tmp;
	503	DRM_DEBUG("\n");
	504
	505	if (driver->driver_features & DRIVER_MODESET) {
	506	pci_unregister_driver(pdriver);
	507	} else {
	508	list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item)
	509	drm_put_dev(dev);
	510	}
	511	DRM_INFO("Module unloaded\n");
	512	}
	513	EXPORT_SYMBOL(drm_pci_exit);