tech-kern archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
DRM scatter/gather mem allocation fix
My T43 running NetBSD 5.0_RC3 + native Xorg + DRM has problems with the 1st
X invocation after bootup; the screen is corrupted, things don't draw right,
etc. If I kill the X server and restart it, it always manages to fix itself
up..
Googling around a bit I found reports of similar issues in FreeBSD PR's
119324 [1] and freedesktop.org bug #11870 [2], which led me to the
following fix in FreeBSD:
http://people.freebsd.org/~rnoland/drm_scatter2.patch
Attached is my update of the fix for NetBSD bus_dma framework; this does
fix my T43 1st-X-since-boot issue, however, it turns out that the define
for the DRM_IOCTL_SG_ALLOC in our xsrc is incorrect -- it's defined as an
input-only ioctl vs. an in-out ioctl. This diff works around that by not
doing the handle-is-valid check in the sg_free ioctl, but I'm not sure if
that's the best thing to do.
Comments welcome.. including on suitability of checking this into the tree,
--rafal
[1] http://www.freebsd.org/cgi/query-pr.cgi?pr=119324
[2] https://bugs.freedesktop.org/show_bug.cgi?id=11870
--
Time is an illusion; lunchtime, doubly so. |/\/\| Rafal Boni
-- Ford Prefect |\/\/|
rafal%pobox.com@localhost
diff --git a/sys/dev/drm/drmP.h b/sys/dev/drm/drmP.h
index 3ffce87..9984f12 100644
--- a/sys/dev/drm/drmP.h
+++ b/sys/dev/drm/drmP.h
@@ -698,11 +698,13 @@ typedef struct drm_agp_head {
} drm_agp_head_t;
typedef struct drm_sg_mem {
- unsigned long handle;
- void *virtual;
- int pages;
- dma_addr_t *busaddr;
- drm_dma_handle_t *dmah; /* Handle to PCI memory for ATI PCIGART table */
+ unsigned long handle;
+ void *virtual;
+ int pages;
+ dma_addr_t *busaddr;
+ struct drm_dma_handle *sg_dmah; /* Handle for sg_pages */
+ struct drm_dma_handle *dmah; /* Handle to PCI memory */
+ /* for ATI PCIGART table */
} drm_sg_mem_t;
typedef TAILQ_HEAD(drm_map_list, drm_local_map) drm_map_list_t;
@@ -1057,6 +1059,7 @@ int drm_agp_unbind(drm_device_t *dev,
drm_agp_binding_t *request);
/* Scatter Gather Support (drm_scatter.c) */
void drm_sg_cleanup(drm_sg_mem_t *entry);
+int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather *
request);
#if defined(__FreeBSD__) || defined (__NetBSD__)
/* sysctl support (drm_sysctl.h) */
@@ -1131,8 +1134,8 @@ int drm_agp_unbind_ioctl(DRM_IOCTL_ARGS);
int drm_agp_bind_ioctl(DRM_IOCTL_ARGS);
/* Scatter Gather Support (drm_scatter.c) */
-int drm_sg_alloc(DRM_IOCTL_ARGS);
-int drm_sg_free(DRM_IOCTL_ARGS);
+int drm_sg_alloc_ioctl(DRM_IOCTL_ARGS);
+int drm_sg_free_ioctl(DRM_IOCTL_ARGS);
/* consistent PCI memory functions (drm_pci.c) */
drm_dma_handle_t *drm_pci_alloc(drm_device_t *dev, size_t size, size_t align,
diff --git a/sys/dev/drm/drm_drv.c b/sys/dev/drm/drm_drv.c
index 046f9c8..31a908b 100644
--- a/sys/dev/drm/drm_drv.c
+++ b/sys/dev/drm/drm_drv.c
@@ -114,8 +114,8 @@ static drm_ioctl_desc_t drm_ioctls[256] = {
[DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)] = { drm_agp_bind_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = { drm_agp_unbind_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
- [DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = { drm_sg_alloc,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
- [DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = { drm_sg_free,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
+ [DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = { drm_sg_alloc_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
+ [DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = { drm_sg_free_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = { drm_wait_vblank, 0 },
};
diff --git a/sys/dev/drm/drm_scatter.c b/sys/dev/drm/drm_scatter.c
index 90326df..ec597ef 100644
--- a/sys/dev/drm/drm_scatter.c
+++ b/sys/dev/drm/drm_scatter.c
@@ -37,68 +37,104 @@ __KERNEL_RCSID(0, "$NetBSD: drm_scatter.c,v 1.7 2008/07/07
00:33:23 mrg Exp $");
__FBSDID("$FreeBSD: src/sys/dev/drm/drm_scatter.c,v 1.3 2006/05/17 06:29:36
anholt Exp $");
*/
-#include "drmP.h"
-
-#define DEBUG_SCATTER 0
+/** @file drm_scatter.c
+ * Allocation of memory for scatter-gather mappings by the graphics chip.
+ *
+ * The memory allocated here is then made into an aperture in the card
+ * by drm_ati_pcigart_init().
+ */
-void drm_sg_cleanup(drm_sg_mem_t *entry)
-{
- free((void *)entry->handle, M_DRM);
- free(entry->busaddr, M_DRM);
- free(entry, M_DRM);
-}
+#include "drmP.h"
-int drm_sg_alloc(DRM_IOCTL_ARGS)
+int
+drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather *request)
{
- DRM_DEVICE;
- drm_scatter_gather_t request;
drm_sg_mem_t *entry;
+ struct drm_dma_handle *dmah;
unsigned long pages;
- int i;
-
- DRM_DEBUG( "%s\n", __FUNCTION__ );
-
- if ( dev->sg )
- return EINVAL;
-
- DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
- sizeof(request) );
+ int nsegs, ret, i;
- entry = malloc(sizeof(*entry), M_DRM, M_WAITOK | M_ZERO);
+ entry = malloc(sizeof(*entry), M_DRM, M_ZERO | M_NOWAIT);
if ( !entry )
return ENOMEM;
- pages = round_page(request.size) / PAGE_SIZE;
- DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages );
+ pages = round_page(request->size) / PAGE_SIZE;
+ DRM_DEBUG( "sg size=%ld pages=%ld\n", request->size, pages );
entry->pages = pages;
entry->busaddr = malloc(pages * sizeof(*entry->busaddr), M_DRM,
- M_WAITOK | M_ZERO);
+ M_ZERO | M_NOWAIT);
if ( !entry->busaddr ) {
- drm_sg_cleanup(entry);
+ free(entry, M_DRM);
return ENOMEM;
}
- entry->handle = (long)malloc(pages << PAGE_SHIFT, M_DRM,
- M_WAITOK | M_ZERO);
- if (entry->handle == 0) {
- drm_sg_cleanup(entry);
+ dmah = malloc(sizeof(struct drm_dma_handle), M_DRM,
+ M_ZERO | M_NOWAIT);
+ if (dmah == NULL) {
+ free(entry->busaddr, M_DRM);
+ free(entry, M_DRM);
return ENOMEM;
}
- for (i = 0; i < pages; i++) {
- entry->busaddr[i] = vtophys(entry->handle + i * PAGE_SIZE);
+ dmah->dmat = dev->pa.pa_dmat;
+
+ ret = bus_dmamem_alloc(dmah->dmat, request->size, PAGE_SIZE, 0,
+ dmah->segs, 1, &nsegs, BUS_DMA_NOWAIT);
+ if (ret != 0) {
+ free(dmah, M_DRM);
+ free(entry->busaddr, M_DRM);
+ free(entry, M_DRM);
+ return ENOMEM;
+ }
+
+ ret = bus_dmamem_map(dmah->dmat, dmah->segs, nsegs, request->size,
+ &dmah->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
+ if (ret != 0) {
+ bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
+ free(dmah, M_DRM);
+ free(entry->busaddr, M_DRM);
+ free(entry, M_DRM);
+ return ENOMEM;
}
+ ret = bus_dmamap_create(dmah->dmat, request->size, pages, PAGE_SIZE,
+ 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &dmah->map);
+
+ if (ret != 0) {
+ bus_dmamem_unmap(dmah->dmat, dmah->addr, request->size);
+ bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
+ free(dmah, M_DRM);
+ free(entry->busaddr, M_DRM);
+ free(entry, M_DRM);
+ return ENOMEM;
+ }
+
+ ret = bus_dmamap_load(dmah->dmat, dmah->map, dmah->addr, request->size,
+ NULL, BUS_DMA_NOWAIT);
+ if (ret != 0) {
+ bus_dmamem_unmap(dmah->dmat, dmah->addr, request->size);
+ bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
+ free(dmah, M_DRM);
+ free(entry->busaddr, M_DRM);
+ free(entry, M_DRM);
+ return ENOMEM;
+ }
+
+ DRM_DEBUG( "sg alloc nsegs = %d\n", dmah->map->dm_nsegs);
+
+ for (i = 0; i < pages; i++) {
+ entry->busaddr[i] = dmah->map->dm_segs[i].ds_addr;
+ }
+
+ entry->handle = (unsigned long)dmah->addr;
+ entry->sg_dmah = dmah;
+
DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle );
entry->virtual = (void *)entry->handle;
- request.handle = entry->handle;
-
- DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
- request,
- sizeof(request) );
+ request->handle = entry->handle;
DRM_LOCK();
if (dev->sg) {
@@ -112,7 +148,47 @@ int drm_sg_alloc(DRM_IOCTL_ARGS)
return 0;
}
-int drm_sg_free(DRM_IOCTL_ARGS)
+int
+drm_sg_alloc_ioctl(DRM_IOCTL_ARGS)
+{
+ DRM_DEVICE;
+ drm_scatter_gather_t request;
+ int ret;
+
+ if ( dev->sg )
+ return EINVAL;
+
+ DRM_DEBUG( "%s\n", __FUNCTION__ );
+
+ DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
+ sizeof(request) );
+
+ ret = drm_sg_alloc(dev, &request);
+ if (ret != 0)
+ return ret;
+
+ DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
+ request,
+ sizeof(request) );
+
+ return 0;
+}
+
+void
+drm_sg_cleanup(drm_sg_mem_t *entry)
+{
+ struct drm_dma_handle *dmah = entry->sg_dmah;
+
+ bus_dmamap_unload(dmah->dmat, dmah->map);
+ bus_dmamem_unmap(dmah->dmat, dmah->addr, entry->pages << PAGE_SHIFT);
+ bus_dmamem_free(dmah->dmat, dmah->segs, 1);
+ free(dmah, M_DRM);
+ free(entry->busaddr, M_DRM);
+ free(entry, M_DRM);
+}
+
+int
+drm_sg_free_ioctl(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
drm_scatter_gather_t request;
@@ -126,8 +202,19 @@ int drm_sg_free(DRM_IOCTL_ARGS)
dev->sg = NULL;
DRM_UNLOCK();
- if ( !entry || entry->handle != request.handle )
+ /*
+ * XXX: current Xsrc defines the SG_ALLOC ioctl as _IOR() vs _IOWR(),
+ * so the handle created in the sg alloc call never makes it back to
+ * userland.
+ *
+ * Allow the handle to be free'd so we don't leak memory; this should
+ * really be done in the locked section above so we don't toss out the
+ * devices' sg list unless the handle matches.
+ */
+ if ( !entry /* || entry->handle != request.handle */ ) {
+ DRM_DEBUG( "sg free: error: %s handle\n", entry ? "invalid" :
"no allocated");
return EINVAL;
+ }
DRM_DEBUG( "sg free virtual = 0x%lx\n", entry->handle );
Home |
Main Index |
Thread Index |
Old Index