usr/src/uts/common/io/drm/drm_pci.c - illumos-gate - Gitiles

 /*
  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */

 /* BEGIN CSTYLED */
 /**
  * \file drm_pci.h
  * \brief PCI consistent, DMA-accessible memory functions.
  *
  * \author Eric Anholt <anholt@FreeBSD.org>
  */

 /*-
  * Copyright 2003 Eric Anholt.
  * 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
  * AUTHOR 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.
  */

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

 #pragma ident	"%Z%%M%	%I%	%E% SMI"

 #include "drmP.h"
 #include <vm/seg_kmem.h>

 #define	PCI_DEVICE(x)	(((x)>>11) & 0x1f)
 #define	PCI_FUNCTION(x)	(((x) & 0x700) >> 8)
 #define	PCI_BUS(x)	(((x) & 0xff0000) >> 16)

 typedef struct drm_pci_resource {
 	uint_t	regnum;
 	unsigned long offset;
 	unsigned long size;
 } drm_pci_resource_t;

 int
 pci_get_info(drm_device_t *softstate, int *bus, int *slot, int *func)
 {
 	int *regs_list;
 	uint_t nregs = 0;

 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, softstate->dip,
 	    DDI_PROP_DONTPASS, "reg", (int **)&regs_list, &nregs)
 	    != DDI_PROP_SUCCESS) {
 		DRM_ERROR("pci_get_info: get pci function bus device failed");
 		goto error;
 	}
 	*bus  = (int)PCI_BUS(regs_list[0]);
 	*slot = (int)PCI_DEVICE(regs_list[0]);
 	*func = (int)PCI_FUNCTION(regs_list[0]);

 	if (nregs > 0) {
 		ddi_prop_free(regs_list);
 	}
 	return (DDI_SUCCESS);
 error:
 	if (nregs > 0) {
 		ddi_prop_free(regs_list);
 	}
 	return (DDI_FAILURE);
 }

 int
 pci_get_irq(drm_device_t *statep)
 {
 	int irq;

 	extern int drm_supp_get_irq(void *);

 	irq = ddi_prop_get_int(DDI_DEV_T_ANY,
 	    statep->dip, DDI_PROP_DONTPASS, "interrupts", -1);

 	if (irq > 0) {
 		irq = drm_supp_get_irq(statep->drm_handle);
 	}

 	return (irq);
 }

 int
 pci_get_vendor(drm_device_t *statep)
 {
 	int vendorid;

 	vendorid = ddi_prop_get_int(DDI_DEV_T_ANY,
 	    statep->dip, DDI_PROP_DONTPASS, "vendor-id", 0);

 	return (vendorid);
 }

 int
 pci_get_device(drm_device_t *statep)
 {
 	int deviceid;

 	deviceid = ddi_prop_get_int(DDI_DEV_T_ANY,
 	    statep->dip, DDI_PROP_DONTPASS, "device-id", 0);

 	return (deviceid);
 }

 void
 drm_core_ioremap(struct drm_local_map *map, drm_device_t *dev)
 {
 	if ((map->type == _DRM_AGP) && dev->agp) {
 		/*
 		 * During AGP mapping initialization, we map AGP aperture
 		 * into kernel space. So, when we access the memory which
 		 * managed by agp gart in kernel space, we have to go
 		 * through two-level address translation: kernel virtual
 		 * address --> aperture address --> physical address. For
 		 * improving this, here in opensourced code, agp_remap()
 		 * gets invoking to dispose the mapping between agp aperture
 		 * and kernel space, and directly map the actual physical
 		 * memory which is allocated to agp gart to kernel space.
 		 * After that, access to physical memory managed by agp gart
 		 * hardware in kernel space doesn't go through agp hardware,
 		 * it will be: kernel virtual ---> physical address.
 		 * Obviously, it is more efficient. But in solaris operating
 		 * system, the ioctl AGPIOC_ALLOCATE of apggart driver does
 		 * not return physical address. We are unable to create the
 		 * direct mapping between kernel space and agp memory. So,
 		 * we remove the calling to agp_remap().
 		 */
 		DRM_DEBUG("drm_core_ioremap: skipping agp_remap\n");
 	} else {
 		(void) drm_ioremap(dev, map);

 	}
 }

 /*ARGSUSED*/
 void
 drm_core_ioremapfree(struct drm_local_map *map, drm_device_t *dev)
 {
 	if (map->type != _DRM_AGP) {
 		if (map->handle && map->size)
 			drm_ioremapfree(map);
 	} else {
 		/*
 		 * Refer to the comments in drm_core_ioremap() where we removed
 		 * the calling to agp_remap(), correspondingly, we remove the
 		 * calling to agp_remap_free(dev, map);
 		 */
 		DRM_DEBUG("drm_core_ioremap: skipping agp_remap_free\n");
 	}
 }

 struct drm_local_map *
 drm_core_findmap(drm_device_t *dev, unsigned long handle)
 {
 	drm_local_map_t *map;

 	DRM_SPINLOCK_ASSERT(&dev->dev_lock);

 /*
  * For the time being, we compare the low 32 bit only,
  * We will hash handle to 32-bit to solve this issue later.
  */
 	TAILQ_FOREACH(map, &dev->maplist, link) {
 		if ((((unsigned long)map->handle) & 0x00000000ffffffff)
 		    == (handle & 0x00000000ffffffff))
 			return (map);
 	}

 	return (NULL);
 }

 /*
  * pci_alloc_consistent()
  */
 static ddi_dma_attr_t	hw_dma_attr = {
 		DMA_ATTR_V0,		/* version */
 		0,			/* addr_lo */
 		0xffffffff,	/* addr_hi */
 		0xffffffff,	/* count_max */
 		4096, 			/* alignment */
 		0xfff,			/* burstsize */
 		1,			/* minxfer */
 		0xffffffff,		/* maxxfer */
 		0xffffffff,		/* seg */
 		1,			/* sgllen */
 		4,			/* granular */
 		0			/* flags */
 };

 static ddi_device_acc_attr_t hw_acc_attr = {
 	DDI_DEVICE_ATTR_V0,
 	DDI_NEVERSWAP_ACC,
 	DDI_STRICTORDER_ACC
 };


 void *
 drm_pci_alloc(drm_device_t *dev, size_t size,
     size_t align,  dma_addr_t maxaddr, int segments)
 {
 	drm_dma_handle_t	*dmah;
 	uint_t	count;
 	int ret = DDI_FAILURE;

 	/* allocat continous physical memory for hw status page */
 	if (align == 0)
 		hw_dma_attr.dma_attr_align =  1;
 	else
 		hw_dma_attr.dma_attr_align = align;

 	hw_dma_attr.dma_attr_addr_hi = maxaddr;
 	hw_dma_attr.dma_attr_sgllen = segments;

 	dmah = kmem_zalloc(sizeof (drm_dma_handle_t), KM_SLEEP);
 	if (ret = ddi_dma_alloc_handle(dev->dip, &hw_dma_attr,
 	    DDI_DMA_SLEEP, NULL, &dmah->dma_hdl)) {
 		DRM_ERROR("drm_pci_alloc:ddi_dma_alloc_handle failed\n");
 		goto err3;
 	}

 	if (ret = ddi_dma_mem_alloc(dmah->dma_hdl, size, &hw_acc_attr,
 	    DDI_DMA_CONSISTENT | IOMEM_DATA_UNCACHED,
 	    DDI_DMA_SLEEP, NULL, (caddr_t *)&dmah->vaddr,
 	    &dmah->real_sz, &dmah->acc_hdl)) {
 		DRM_ERROR("drm_pci_alloc: ddi_dma_mem_alloc failed\n");
 		goto err2;
 	}

 	ret = ddi_dma_addr_bind_handle(dmah->dma_hdl, NULL,
 	    (caddr_t)dmah->vaddr, dmah->real_sz,
 	    DDI_DMA_RDWR|DDI_DMA_CONSISTENT,
 	    DDI_DMA_SLEEP, NULL, &dmah->cookie,  &count);
 	if (ret != DDI_DMA_MAPPED) {
 		DRM_ERROR("drm_pci_alloc: alloc phys memory failed");
 		goto err1;
 	}

 	if (count > segments) {
 		(void) ddi_dma_unbind_handle(dmah->dma_hdl);
 		goto err1;
 	}

 	dmah->cookie_num = count;
 	if (count == 1)
 		dmah->paddr = dmah->cookie.dmac_address;

 	return (dmah);

 err1:
 	ddi_dma_mem_free(&dmah->acc_hdl);
 err2:
 	ddi_dma_free_handle(&dmah->dma_hdl);
 err3:
 	kmem_free(dmah, sizeof (*dmah));
 	return (NULL);
 }

 /*
  * pci_free_consistent()
  */
 /*ARGSUSED*/
 void
 drm_pci_free(drm_device_t *dev, drm_dma_handle_t *dmah)
 {
 	ASSERT(dmah != NULL);
 	(void) ddi_dma_unbind_handle(dmah->dma_hdl);
 	ddi_dma_mem_free(&dmah->acc_hdl);
 	ddi_dma_free_handle(&dmah->dma_hdl);
 	kmem_free(dmah, sizeof (drm_dma_handle_t));
 }

 int
 do_get_pci_res(drm_device_t *dev, drm_pci_resource_t *resp)
 {
 	int length;
 	pci_regspec_t	*regs;

 	if (ddi_getlongprop(
 	    DDI_DEV_T_ANY, dev->dip, DDI_PROP_DONTPASS,
 	    "assigned-addresses", (caddr_t)&regs, &length) !=
 	    DDI_PROP_SUCCESS) {
 		DRM_ERROR("do_get_pci_res: ddi_getlongprop failed!\n");
 		return (EFAULT);
 	}
 	resp->offset =
 	    (unsigned long)regs[resp->regnum].pci_phys_low;
 	resp->size =
 	    (unsigned long)regs[resp->regnum].pci_size_low;
 	kmem_free(regs, (size_t)length);

 	return (0);
 }

 /*ARGSUSED*/
 unsigned long
 drm_get_resource_start(drm_device_t *softstate, unsigned int regnum)
 {
 	drm_pci_resource_t res;
 	int ret;

 	res.regnum = regnum;

 	ret = do_get_pci_res(softstate, &res);

 	if (ret != 0) {
 		DRM_ERROR("drm_get_resource_start: ioctl failed");
 		return (0);
 	}

 	return (res.offset);

 }

 /*ARGSUSED*/
 unsigned long
 drm_get_resource_len(drm_device_t *softstate, unsigned int regnum)
 {
 	drm_pci_resource_t res;
 	int ret;

 	res.regnum = regnum;

 	ret = do_get_pci_res(softstate, &res);

 	if (ret != 0) {
 		DRM_ERROR("drm_get_resource_len: ioctl failed");
 		return (0);
 	}

 	return (res.size);
 }
	/*
	* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	/* BEGIN CSTYLED */
	/**
	* \file drm_pci.h
	* \brief PCI consistent, DMA-accessible memory functions.
	*
	* \author Eric Anholt <anholt@FreeBSD.org>
	*/

	/*-
	* Copyright 2003 Eric Anholt.
	* 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
	* AUTHOR 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.
	*/

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

	#pragma ident "%Z%%M% %I% %E% SMI"

	#include "drmP.h"
	#include <vm/seg_kmem.h>

	#define PCI_DEVICE(x) (((x)>>11) & 0x1f)
	#define PCI_FUNCTION(x) (((x) & 0x700) >> 8)
	#define PCI_BUS(x) (((x) & 0xff0000) >> 16)

	typedef struct drm_pci_resource {
	uint_t regnum;
	unsigned long offset;
	unsigned long size;
	} drm_pci_resource_t;

	int
	pci_get_info(drm_device_t softstate, int bus, int slot, int func)
	{
	int *regs_list;
	uint_t nregs = 0;

	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, softstate->dip,
	DDI_PROP_DONTPASS, "reg", (int **)&regs_list, &nregs)
	!= DDI_PROP_SUCCESS) {
	DRM_ERROR("pci_get_info: get pci function bus device failed");
	goto error;
	}
	*bus = (int)PCI_BUS(regs_list[0]);
	*slot = (int)PCI_DEVICE(regs_list[0]);
	*func = (int)PCI_FUNCTION(regs_list[0]);

	if (nregs > 0) {
	ddi_prop_free(regs_list);
	}
	return (DDI_SUCCESS);
	error:
	if (nregs > 0) {
	ddi_prop_free(regs_list);
	}
	return (DDI_FAILURE);
	}

	int
	pci_get_irq(drm_device_t *statep)
	{
	int irq;

	extern int drm_supp_get_irq(void *);

	irq = ddi_prop_get_int(DDI_DEV_T_ANY,
	statep->dip, DDI_PROP_DONTPASS, "interrupts", -1);

	if (irq > 0) {
	irq = drm_supp_get_irq(statep->drm_handle);
	}

	return (irq);
	}

	int
	pci_get_vendor(drm_device_t *statep)
	{
	int vendorid;

	vendorid = ddi_prop_get_int(DDI_DEV_T_ANY,
	statep->dip, DDI_PROP_DONTPASS, "vendor-id", 0);

	return (vendorid);
	}

	int
	pci_get_device(drm_device_t *statep)
	{
	int deviceid;

	deviceid = ddi_prop_get_int(DDI_DEV_T_ANY,
	statep->dip, DDI_PROP_DONTPASS, "device-id", 0);

	return (deviceid);
	}

	void
	drm_core_ioremap(struct drm_local_map map, drm_device_t dev)
	{
	if ((map->type == _DRM_AGP) && dev->agp) {
	/*
	* During AGP mapping initialization, we map AGP aperture
	* into kernel space. So, when we access the memory which
	* managed by agp gart in kernel space, we have to go
	* through two-level address translation: kernel virtual
	* address --> aperture address --> physical address. For
	* improving this, here in opensourced code, agp_remap()
	* gets invoking to dispose the mapping between agp aperture
	* and kernel space, and directly map the actual physical
	* memory which is allocated to agp gart to kernel space.
	* After that, access to physical memory managed by agp gart
	* hardware in kernel space doesn't go through agp hardware,
	* it will be: kernel virtual ---> physical address.
	* Obviously, it is more efficient. But in solaris operating
	* system, the ioctl AGPIOC_ALLOCATE of apggart driver does
	* not return physical address. We are unable to create the
	* direct mapping between kernel space and agp memory. So,
	* we remove the calling to agp_remap().
	*/
	DRM_DEBUG("drm_core_ioremap: skipping agp_remap\n");
	} else {
	(void) drm_ioremap(dev, map);

	}
	}

	/ARGSUSED/
	void
	drm_core_ioremapfree(struct drm_local_map map, drm_device_t dev)
	{
	if (map->type != _DRM_AGP) {
	if (map->handle && map->size)
	drm_ioremapfree(map);
	} else {
	/*
	* Refer to the comments in drm_core_ioremap() where we removed
	* the calling to agp_remap(), correspondingly, we remove the
	* calling to agp_remap_free(dev, map);
	*/
	DRM_DEBUG("drm_core_ioremap: skipping agp_remap_free\n");
	}
	}

	struct drm_local_map *
	drm_core_findmap(drm_device_t *dev, unsigned long handle)
	{
	drm_local_map_t *map;

	DRM_SPINLOCK_ASSERT(&dev->dev_lock);

	/*
	* For the time being, we compare the low 32 bit only,
	* We will hash handle to 32-bit to solve this issue later.
	*/
	TAILQ_FOREACH(map, &dev->maplist, link) {
	if ((((unsigned long)map->handle) & 0x00000000ffffffff)
	== (handle & 0x00000000ffffffff))
	return (map);
	}

	return (NULL);
	}

	/*
	* pci_alloc_consistent()
	*/
	static ddi_dma_attr_t hw_dma_attr = {
	DMA_ATTR_V0, /* version */
	0, /* addr_lo */
	0xffffffff, /* addr_hi */
	0xffffffff, /* count_max */
	4096, /* alignment */
	0xfff, /* burstsize */
	1, /* minxfer */
	0xffffffff, /* maxxfer */
	0xffffffff, /* seg */
	1, /* sgllen */
	4, /* granular */
	0 /* flags */
	};

	static ddi_device_acc_attr_t hw_acc_attr = {
	DDI_DEVICE_ATTR_V0,
	DDI_NEVERSWAP_ACC,
	DDI_STRICTORDER_ACC
	};


	void *
	drm_pci_alloc(drm_device_t *dev, size_t size,
	size_t align, dma_addr_t maxaddr, int segments)
	{
	drm_dma_handle_t *dmah;
	uint_t count;
	int ret = DDI_FAILURE;

	/* allocat continous physical memory for hw status page */
	if (align == 0)
	hw_dma_attr.dma_attr_align = 1;
	else
	hw_dma_attr.dma_attr_align = align;

	hw_dma_attr.dma_attr_addr_hi = maxaddr;
	hw_dma_attr.dma_attr_sgllen = segments;

	dmah = kmem_zalloc(sizeof (drm_dma_handle_t), KM_SLEEP);
	if (ret = ddi_dma_alloc_handle(dev->dip, &hw_dma_attr,
	DDI_DMA_SLEEP, NULL, &dmah->dma_hdl)) {
	DRM_ERROR("drm_pci_alloc:ddi_dma_alloc_handle failed\n");
	goto err3;
	}

	if (ret = ddi_dma_mem_alloc(dmah->dma_hdl, size, &hw_acc_attr,
	DDI_DMA_CONSISTENT \| IOMEM_DATA_UNCACHED,
	DDI_DMA_SLEEP, NULL, (caddr_t *)&dmah->vaddr,
	&dmah->real_sz, &dmah->acc_hdl)) {
	DRM_ERROR("drm_pci_alloc: ddi_dma_mem_alloc failed\n");
	goto err2;
	}

	ret = ddi_dma_addr_bind_handle(dmah->dma_hdl, NULL,
	(caddr_t)dmah->vaddr, dmah->real_sz,
	DDI_DMA_RDWR\|DDI_DMA_CONSISTENT,
	DDI_DMA_SLEEP, NULL, &dmah->cookie, &count);
	if (ret != DDI_DMA_MAPPED) {
	DRM_ERROR("drm_pci_alloc: alloc phys memory failed");
	goto err1;
	}

	if (count > segments) {
	(void) ddi_dma_unbind_handle(dmah->dma_hdl);
	goto err1;
	}

	dmah->cookie_num = count;
	if (count == 1)
	dmah->paddr = dmah->cookie.dmac_address;

	return (dmah);

	err1:
	ddi_dma_mem_free(&dmah->acc_hdl);
	err2:
	ddi_dma_free_handle(&dmah->dma_hdl);
	err3:
	kmem_free(dmah, sizeof (*dmah));
	return (NULL);
	}

	/*
	* pci_free_consistent()
	*/
	/ARGSUSED/
	void
	drm_pci_free(drm_device_t dev, drm_dma_handle_t dmah)
	{
	ASSERT(dmah != NULL);
	(void) ddi_dma_unbind_handle(dmah->dma_hdl);
	ddi_dma_mem_free(&dmah->acc_hdl);
	ddi_dma_free_handle(&dmah->dma_hdl);
	kmem_free(dmah, sizeof (drm_dma_handle_t));
	}

	int
	do_get_pci_res(drm_device_t dev, drm_pci_resource_t resp)
	{
	int length;
	pci_regspec_t *regs;

	if (ddi_getlongprop(
	DDI_DEV_T_ANY, dev->dip, DDI_PROP_DONTPASS,
	"assigned-addresses", (caddr_t)&regs, &length) !=
	DDI_PROP_SUCCESS) {
	DRM_ERROR("do_get_pci_res: ddi_getlongprop failed!\n");
	return (EFAULT);
	}
	resp->offset =
	(unsigned long)regs[resp->regnum].pci_phys_low;
	resp->size =
	(unsigned long)regs[resp->regnum].pci_size_low;
	kmem_free(regs, (size_t)length);

	return (0);
	}

	/ARGSUSED/
	unsigned long
	drm_get_resource_start(drm_device_t *softstate, unsigned int regnum)
	{
	drm_pci_resource_t res;
	int ret;

	res.regnum = regnum;

	ret = do_get_pci_res(softstate, &res);

	if (ret != 0) {
	DRM_ERROR("drm_get_resource_start: ioctl failed");
	return (0);
	}

	return (res.offset);

	}

	/ARGSUSED/
	unsigned long
	drm_get_resource_len(drm_device_t *softstate, unsigned int regnum)
	{
	drm_pci_resource_t res;
	int ret;

	res.regnum = regnum;

	ret = do_get_pci_res(softstate, &res);

	if (ret != 0) {
	DRM_ERROR("drm_get_resource_len: ioctl failed");
	return (0);
	}

	return (res.size);
	}