Merge branch 'drm-patches' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6 (63e8d911) · Commits · e / devices / android_kernel_sony_msm8998

drivers/char/drm/drmP.h

+7 −9

Original line number	Original line	Diff line number	Diff line
	@@ -357,6 +357,12 @@ typedef struct drm_freelist {
	spinlock_t lock;		spinlock_t lock;
	} drm_freelist_t;		} drm_freelist_t;

			typedef struct drm_dma_handle {
			dma_addr_t busaddr;
			void *vaddr;
			size_t size;
			} drm_dma_handle_t;

	/**		/**
	* Buffer entry. There is one of this for each buffer size order.		* Buffer entry. There is one of this for each buffer size order.
	*/		*/
	@@ -366,7 +372,7 @@ typedef struct drm_buf_entry {
	drm_buf_t buflist; /< buffer list /		drm_buf_t buflist; /< buffer list /
	int seg_count;		int seg_count;
	int page_order;		int page_order;
	unsigned long *seglist;		drm_dma_handle_t **seglist;

	drm_freelist_t freelist;		drm_freelist_t freelist;
	} drm_buf_entry_t;		} drm_buf_entry_t;
	@@ -483,12 +489,6 @@ typedef struct drm_sigdata {
	drm_hw_lock_t *lock;		drm_hw_lock_t *lock;
	} drm_sigdata_t;		} drm_sigdata_t;

	typedef struct drm_dma_handle {
	dma_addr_t busaddr;
	void *vaddr;
	size_t size;
	} drm_dma_handle_t;

	/**		/**
	* Mappings list		* Mappings list
	*/		*/
	@@ -813,8 +813,6 @@ extern void drm_mem_init(void);
	extern int drm_mem_info(char buf, char *start, off_t offset,		extern int drm_mem_info(char buf, char *start, off_t offset,
	int request, int eof, void data);		int request, int eof, void data);
	extern void drm_realloc(void oldpt, size_t oldsize, size_t size, int area);		extern void drm_realloc(void oldpt, size_t oldsize, size_t size, int area);
	extern unsigned long drm_alloc_pages(int order, int area);
	extern void drm_free_pages(unsigned long address, int order, int area);
	extern void *drm_ioremap(unsigned long offset, unsigned long size,		extern void *drm_ioremap(unsigned long offset, unsigned long size,
	drm_device_t * dev);		drm_device_t * dev);
	extern void *drm_ioremap_nocache(unsigned long offset, unsigned long size,		extern void *drm_ioremap_nocache(unsigned long offset, unsigned long size,

drivers/char/drm/drm_bufs.c

+11 −9

Original line number	Original line	Diff line number	Diff line
	@@ -474,8 +474,7 @@ static void drm_cleanup_buf_error(drm_device_t * dev, drm_buf_entry_t * entry)
	if (entry->seg_count) {		if (entry->seg_count) {
	for (i = 0; i < entry->seg_count; i++) {		for (i = 0; i < entry->seg_count; i++) {
	if (entry->seglist[i]) {		if (entry->seglist[i]) {
	drm_free_pages(entry->seglist[i],		drm_pci_free(dev, entry->seglist[i]);
	entry->page_order, DRM_MEM_DMA);
	}		}
	}		}
	drm_free(entry->seglist,		drm_free(entry->seglist,
	@@ -678,7 +677,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
	int total;		int total;
	int page_order;		int page_order;
	drm_buf_entry_t *entry;		drm_buf_entry_t *entry;
	unsigned long page;		drm_dma_handle_t *dmah;
	drm_buf_t *buf;		drm_buf_t *buf;
	int alignment;		int alignment;
	unsigned long offset;		unsigned long offset;
	@@ -781,8 +780,10 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
	page_count = 0;		page_count = 0;

	while (entry->buf_count < count) {		while (entry->buf_count < count) {
	page = drm_alloc_pages(page_order, DRM_MEM_DMA);
	if (!page) {		dmah = drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000, 0xfffffffful);

			if (!dmah) {
	/* Set count correctly so we free the proper amount. */		/* Set count correctly so we free the proper amount. */
	entry->buf_count = count;		entry->buf_count = count;
	entry->seg_count = count;		entry->seg_count = count;
	@@ -794,13 +795,13 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
	atomic_dec(&dev->buf_alloc);		atomic_dec(&dev->buf_alloc);
	return -ENOMEM;		return -ENOMEM;
	}		}
	entry->seglist[entry->seg_count++] = page;		entry->seglist[entry->seg_count++] = dmah;
	for (i = 0; i < (1 << page_order); i++) {		for (i = 0; i < (1 << page_order); i++) {
	DRM_DEBUG("page %d @ 0x%08lx\n",		DRM_DEBUG("page %d @ 0x%08lx\n",
	dma->page_count + page_count,		dma->page_count + page_count,
	page + PAGE_SIZE * i);		(unsigned long)dmah->vaddr + PAGE_SIZE * i);
	temp_pagelist[dma->page_count + page_count++]		temp_pagelist[dma->page_count + page_count++]
	= page + PAGE_SIZE * i;		= (unsigned long)dmah->vaddr + PAGE_SIZE * i;
	}		}
	for (offset = 0;		for (offset = 0;
	offset + size <= total && entry->buf_count < count;		offset + size <= total && entry->buf_count < count;
	@@ -811,7 +812,8 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
	buf->order = order;		buf->order = order;
	buf->used = 0;		buf->used = 0;
	buf->offset = (dma->byte_count + byte_count + offset);		buf->offset = (dma->byte_count + byte_count + offset);
	buf->address = (void *)(page + offset);		buf->address = (void *)(dmah->vaddr + offset);
			buf->bus_address = dmah->busaddr + offset;
	buf->next = NULL;		buf->next = NULL;
	buf->waiting = 0;		buf->waiting = 0;
	buf->pending = 0;		buf->pending = 0;

drivers/char/drm/drm_dma.c

+1 −3

Original line number	Original line	Diff line number	Diff line
	@@ -85,9 +85,7 @@ void drm_dma_takedown(drm_device_t * dev)
	dma->bufs[i].seg_count);		dma->bufs[i].seg_count);
	for (j = 0; j < dma->bufs[i].seg_count; j++) {		for (j = 0; j < dma->bufs[i].seg_count; j++) {
	if (dma->bufs[i].seglist[j]) {		if (dma->bufs[i].seglist[j]) {
	drm_free_pages(dma->bufs[i].seglist[j],		drm_pci_free(dev, dma->bufs[i].seglist[j]);
	dma->bufs[i].page_order,
	DRM_MEM_DMA);
	}		}
	}		}
	drm_free(dma->bufs[i].seglist,		drm_free(dma->bufs[i].seglist,

drivers/char/drm/drm_memory.c

+0 −59

Original line number	Original line	Diff line number	Diff line
	@@ -79,65 +79,6 @@ void drm_realloc(void oldpt, size_t oldsize, size_t size, int area)
	return pt;		return pt;
	}		}

	/**
	* Allocate pages.
	*
	* \param order size order.
	* \param area memory area. (Not used.)
	* \return page address on success, or zero on failure.
	*
	* Allocate and reserve free pages.
	*/
	unsigned long drm_alloc_pages(int order, int area)
	{
	unsigned long address;
	unsigned long bytes = PAGE_SIZE << order;
	unsigned long addr;
	unsigned int sz;

	address = __get_free_pages(GFP_KERNEL\|__GFP_COMP, order);
	if (!address)
	return 0;

	/* Zero */
	memset((void *)address, 0, bytes);

	/* Reserve */
	for (addr = address, sz = bytes;
	sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
	SetPageReserved(virt_to_page(addr));
	}

	return address;
	}

	/**
	* Free pages.
	*
	* \param address address of the pages to free.
	* \param order size order.
	* \param area memory area. (Not used.)
	*
	* Unreserve and free pages allocated by alloc_pages().
	*/
	void drm_free_pages(unsigned long address, int order, int area)
	{
	unsigned long bytes = PAGE_SIZE << order;
	unsigned long addr;
	unsigned int sz;

	if (!address)
	return;

	/* Unreserve */
	for (addr = address, sz = bytes;
	sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
	ClearPageReserved(virt_to_page(addr));
	}

	free_pages(address, order);
	}

	#if __OS_HAS_AGP		#if __OS_HAS_AGP
	/** Wrapper around agp_allocate_memory() */		/** Wrapper around agp_allocate_memory() */
	DRM_AGP_MEM drm_alloc_agp(drm_device_t dev, int pages, u32 type)		DRM_AGP_MEM drm_alloc_agp(drm_device_t dev, int pages, u32 type)

drivers/char/drm/drm_memory_debug.h

+0 −70

Original line number	Original line	Diff line number	Diff line
	@@ -206,76 +206,6 @@ void drm_free (void *pt, size_t size, int area) {
	}		}
	}		}

	unsigned long drm_alloc_pages (int order, int area) {
	unsigned long address;
	unsigned long bytes = PAGE_SIZE << order;
	unsigned long addr;
	unsigned int sz;

	spin_lock(&drm_mem_lock);
	if ((drm_ram_used >> PAGE_SHIFT)
	> (DRM_RAM_PERCENT * drm_ram_available) / 100) {
	spin_unlock(&drm_mem_lock);
	return 0;
	}
	spin_unlock(&drm_mem_lock);

	address = __get_free_pages(GFP_KERNEL\|__GFP_COMP, order);
	if (!address) {
	spin_lock(&drm_mem_lock);
	++drm_mem_stats[area].fail_count;
	spin_unlock(&drm_mem_lock);
	return 0;
	}
	spin_lock(&drm_mem_lock);
	++drm_mem_stats[area].succeed_count;
	drm_mem_stats[area].bytes_allocated += bytes;
	drm_ram_used += bytes;
	spin_unlock(&drm_mem_lock);

	/* Zero outside the lock */
	memset((void *)address, 0, bytes);

	/* Reserve */
	for (addr = address, sz = bytes;
	sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
	SetPageReserved(virt_to_page(addr));
	}

	return address;
	}

	void drm_free_pages (unsigned long address, int order, int area) {
	unsigned long bytes = PAGE_SIZE << order;
	int alloc_count;
	int free_count;
	unsigned long addr;
	unsigned int sz;

	if (!address) {
	DRM_MEM_ERROR(area, "Attempt to free address 0\n");
	} else {
	/* Unreserve */
	for (addr = address, sz = bytes;
	sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
	ClearPageReserved(virt_to_page(addr));
	}
	free_pages(address, order);
	}

	spin_lock(&drm_mem_lock);
	free_count = ++drm_mem_stats[area].free_count;
	alloc_count = drm_mem_stats[area].succeed_count;
	drm_mem_stats[area].bytes_freed += bytes;
	drm_ram_used -= bytes;
	spin_unlock(&drm_mem_lock);
	if (free_count > alloc_count) {
	DRM_MEM_ERROR(area,
	"Excess frees: %d frees, %d allocs\n",
	free_count, alloc_count);
	}
	}

	void *drm_ioremap (unsigned long offset, unsigned long size,		void *drm_ioremap (unsigned long offset, unsigned long size,
	drm_device_t * dev) {		drm_device_t * dev) {
	void *pt;		void *pt;