WebSVN – Kolibri OS – Diff – /drivers/video/drm/radeon/radeon_gart.c


/*
 * Copyright 2008 Advanced Micro Devices, Inc.
 * Copyright 2008 Red Hat Inc.
 * Copyright 2009 Jerome Glisse.
 *
 * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
 *
 * Authors: Dave Airlie
 *          Alex Deucher
 *          Jerome Glisse
 */
#include "drmP.h"
#include "radeon_drm.h"
#include "radeon.h"
#include "radeon_reg.h"
 
 
static inline void *
pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
                      addr_t *dma_handle)
{
 
    size = (size + 0x7FFF) & ~0x7FFF;
 
    *dma_handle = AllocPages(size >> 12);
    return (void*)MapIoMem(*dma_handle, size, PG_SW+PG_NOCACHE);
}
 
/*
 * Common GART table functions.
 */
int radeon_gart_table_ram_alloc(struct radeon_device *rdev)
{
	void *ptr;
 
    ptr = pci_alloc_consistent(rdev->pdev, rdev->gart.table_size,
                  &rdev->gart.table_addr);
	if (ptr == NULL) {
		return -ENOMEM;
	}
#ifdef CONFIG_X86
	if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480 ||
	    rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) {
		set_memory_uc((unsigned long)ptr,
			      rdev->gart.table_size >> PAGE_SHIFT);
	}
#endif
	rdev->gart.table.ram.ptr = ptr;
	memset((void *)rdev->gart.table.ram.ptr, 0, rdev->gart.table_size);
	return 0;
}
 
void radeon_gart_table_ram_free(struct radeon_device *rdev)
{
	if (rdev->gart.table.ram.ptr == NULL) {
		return;
	}
#ifdef CONFIG_X86
	if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480 ||
	    rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) {
		set_memory_wb((unsigned long)rdev->gart.table.ram.ptr,
			      rdev->gart.table_size >> PAGE_SHIFT);
	}
#endif
//   pci_free_consistent(rdev->pdev, rdev->gart.table_size,
//               (void *)rdev->gart.table.ram.ptr,
//               rdev->gart.table_addr);
	rdev->gart.table.ram.ptr = NULL;
	rdev->gart.table_addr = 0;
}
 
int radeon_gart_table_vram_alloc(struct radeon_device *rdev)
{
    int r;
 
    if (rdev->gart.table.vram.robj == NULL) {
		r = radeon_bo_create(rdev, NULL, rdev->gart.table_size,
					true, RADEON_GEM_DOMAIN_VRAM,
					&rdev->gart.table.vram.robj);
        if (r) {
            return r;
        }
    }
	return 0;
}
 
int radeon_gart_table_vram_pin(struct radeon_device *rdev)
{
	uint64_t gpu_addr;
	int r;
 
	r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
	if (unlikely(r != 0))
		return r;
	r = radeon_bo_pin(rdev->gart.table.vram.robj,
                  RADEON_GEM_DOMAIN_VRAM, &gpu_addr);
    if (r) {
		radeon_bo_unreserve(rdev->gart.table.vram.robj);
        return r;
    }
	r = radeon_bo_kmap(rdev->gart.table.vram.robj,
                   (void **)&rdev->gart.table.vram.ptr);
	if (r)
		radeon_bo_unpin(rdev->gart.table.vram.robj);
	radeon_bo_unreserve(rdev->gart.table.vram.robj);
	rdev->gart.table_addr = gpu_addr;
    return r;
}
 
void radeon_gart_table_vram_free(struct radeon_device *rdev)
{
	int r;
 
	if (rdev->gart.table.vram.robj == NULL) {
		return;
	}
	r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
	if (likely(r == 0)) {
		radeon_bo_kunmap(rdev->gart.table.vram.robj);
		radeon_bo_unpin(rdev->gart.table.vram.robj);
		radeon_bo_unreserve(rdev->gart.table.vram.robj);
	}
	radeon_bo_unref(&rdev->gart.table.vram.robj);
}
 
 
 
 
/*
 * Common gart functions.
 */
void radeon_gart_unbind(struct radeon_device *rdev, unsigned offset,
			int pages)
{
	unsigned t;
	unsigned p;
	int i, j;
	u64 page_base;
 
	if (!rdev->gart.ready) {
		WARN(1, "trying to unbind memory to unitialized GART !\n");
		return;
	}
	t = offset / RADEON_GPU_PAGE_SIZE;
	p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);
	for (i = 0; i < pages; i++, p++) {
		if (rdev->gart.pages[p]) {
//           pci_unmap_page(rdev->pdev, rdev->gart.pages_addr[p],
//                      PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
			rdev->gart.pages[p] = NULL;
			rdev->gart.pages_addr[p] = rdev->dummy_page.addr;
			page_base = rdev->gart.pages_addr[p];
			for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {
				radeon_gart_set_page(rdev, t, page_base);
				page_base += RADEON_GPU_PAGE_SIZE;
			}
		}
	}
	mb();
	radeon_gart_tlb_flush(rdev);
}
 
int radeon_gart_bind(struct radeon_device *rdev, unsigned offset,
             int pages, u32_t *pagelist)
{
    unsigned t;
    unsigned p;
    uint64_t page_base;
    int i, j;
 
    ENTER();
 
    dbgprintf("offset %x pages %x list %x\n",
               offset, pages, pagelist);
 
    if (!rdev->gart.ready) {
        DRM_ERROR("trying to bind memory to unitialized GART !\n");
        return -EINVAL;
    }
	t = offset / RADEON_GPU_PAGE_SIZE;
	p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);
 
    for (i = 0; i < pages; i++, p++) {
        /* we need to support large memory configurations */
        /* assume that unbind have already been call on the range */
 
        rdev->gart.pages_addr[p] = pagelist[i] & ~4095;
 
 
        rdev->gart.pages[p] = pagelist[i];
		page_base = rdev->gart.pages_addr[p];
		for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {
            radeon_gart_set_page(rdev, t, page_base);
			page_base += RADEON_GPU_PAGE_SIZE;
        }
    }
    mb();
    radeon_gart_tlb_flush(rdev);
    return 0;
}
 
void radeon_gart_restore(struct radeon_device *rdev)
{
	int i, j, t;
	u64 page_base;
 
	for (i = 0, t = 0; i < rdev->gart.num_cpu_pages; i++) {
		page_base = rdev->gart.pages_addr[i];
		for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {
			radeon_gart_set_page(rdev, t, page_base);
			page_base += RADEON_GPU_PAGE_SIZE;
		}
	}
	mb();
	radeon_gart_tlb_flush(rdev);
}
 
int radeon_gart_init(struct radeon_device *rdev)
{
	int r, i;
 
    if (rdev->gart.pages) {
        return 0;
    }
	/* We need PAGE_SIZE >= RADEON_GPU_PAGE_SIZE */
	if (PAGE_SIZE < RADEON_GPU_PAGE_SIZE) {
        DRM_ERROR("Page size is smaller than GPU page size!\n");
        return -EINVAL;
    }
	r = radeon_dummy_page_init(rdev);
	if (r)
		return r;
    /* Compute table size */
    rdev->gart.num_cpu_pages = rdev->mc.gtt_size / PAGE_SIZE;
	rdev->gart.num_gpu_pages = rdev->mc.gtt_size / RADEON_GPU_PAGE_SIZE;
    DRM_INFO("GART: num cpu pages %u, num gpu pages %u\n",
         rdev->gart.num_cpu_pages, rdev->gart.num_gpu_pages);
    /* Allocate pages table */
    rdev->gart.pages = kzalloc(sizeof(void *) * rdev->gart.num_cpu_pages,
                   GFP_KERNEL);
    if (rdev->gart.pages == NULL) {
		radeon_gart_fini(rdev);
        return -ENOMEM;
    }
	rdev->gart.pages_addr = kzalloc(sizeof(dma_addr_t) *
                    rdev->gart.num_cpu_pages, GFP_KERNEL);
    if (rdev->gart.pages_addr == NULL) {
		radeon_gart_fini(rdev);
        return -ENOMEM;
    }
	/* set GART entry to point to the dummy page by default */
	for (i = 0; i < rdev->gart.num_cpu_pages; i++) {
		rdev->gart.pages_addr[i] = rdev->dummy_page.addr;
	}
    return 0;
}
 
void radeon_gart_fini(struct radeon_device *rdev)
{
	if (rdev->gart.pages && rdev->gart.pages_addr && rdev->gart.ready) {
		/* unbind pages */
		radeon_gart_unbind(rdev, 0, rdev->gart.num_cpu_pages);
	}
	rdev->gart.ready = false;
	kfree(rdev->gart.pages);
	kfree(rdev->gart.pages_addr);
	rdev->gart.pages = NULL;
	rdev->gart.pages_addr = NULL;
}



Rev 1430	Rev 1631
1	/*	1	/*
2	* Copyright 2008 Advanced Micro Devices, Inc.	2	* Copyright 2008 Advanced Micro Devices, Inc.
3	* Copyright 2008 Red Hat Inc.	3	* Copyright 2008 Red Hat Inc.
4	* Copyright 2009 Jerome Glisse.	4	* Copyright 2009 Jerome Glisse.
5	*	5	*
6	* Permission is hereby granted, free of charge, to any person obtaining a	6	* Permission is hereby granted, free of charge, to any person obtaining a
7	* copy of this software and associated documentation files (the "Software"),	7	* copy of this software and associated documentation files (the "Software"),
8	* to deal in the Software without restriction, including without limitation	8	* to deal in the Software without restriction, including without limitation
9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,	9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
10	* and/or sell copies of the Software, and to permit persons to whom the	10	* and/or sell copies of the Software, and to permit persons to whom the
11	* Software is furnished to do so, subject to the following conditions:	11	* Software is furnished to do so, subject to the following conditions:
12	*	12	*
13	* The above copyright notice and this permission notice shall be included in	13	* The above copyright notice and this permission notice shall be included in
14	* all copies or substantial portions of the Software.	14	* all copies or substantial portions of the Software.
15	*	15	*
16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR	19	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,	20	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR	21	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22	* OTHER DEALINGS IN THE SOFTWARE.	22	* OTHER DEALINGS IN THE SOFTWARE.
23	*	23	*
24	* Authors: Dave Airlie	24	* Authors: Dave Airlie
25	* Alex Deucher	25	* Alex Deucher
26	* Jerome Glisse	26	* Jerome Glisse
27	*/	27	*/
28	#include "drmP.h"	28	#include "drmP.h"
29	#include "radeon_drm.h"	29	#include "radeon_drm.h"
30	#include "radeon.h"	30	#include "radeon.h"
31	#include "radeon_reg.h"	31	#include "radeon_reg.h"
-		32
-		33
-		34	static inline void *
-		35	pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
-		36	addr_t *dma_handle)
-		37	{
-		38
-		39	size = (size + 0x7FFF) & ~0x7FFF;
-		40
-		41	*dma_handle = AllocPages(size >> 12);
-		42	return (void)MapIoMem(dma_handle, size, PG_SW+PG_NOCACHE);
-		43	}
32		44
33	/*	45	/*
34	* Common GART table functions.	46	* Common GART table functions.
35	*/	47	*/
36	int radeon_gart_table_ram_alloc(struct radeon_device *rdev)	48	int radeon_gart_table_ram_alloc(struct radeon_device *rdev)
37	{	49	{
38	void *ptr;	50	void *ptr;
39		51
40	ptr = pci_alloc_consistent(rdev->pdev, rdev->gart.table_size,	52	ptr = pci_alloc_consistent(rdev->pdev, rdev->gart.table_size,
41	&rdev->gart.table_addr);	53	&rdev->gart.table_addr);
42	if (ptr == NULL) {	54	if (ptr == NULL) {
43	return -ENOMEM;	55	return -ENOMEM;
44	}	56	}
45	#ifdef CONFIG_X86	57	#ifdef CONFIG_X86
46	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480 \|\|	58	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480 \|\|
47	rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) {	59	rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) {
48	set_memory_uc((unsigned long)ptr,	60	set_memory_uc((unsigned long)ptr,
49	rdev->gart.table_size >> PAGE_SHIFT);	61	rdev->gart.table_size >> PAGE_SHIFT);
50	}	62	}
51	#endif	63	#endif
52	rdev->gart.table.ram.ptr = ptr;	64	rdev->gart.table.ram.ptr = ptr;
53	memset((void *)rdev->gart.table.ram.ptr, 0, rdev->gart.table_size);	65	memset((void *)rdev->gart.table.ram.ptr, 0, rdev->gart.table_size);
54	return 0;	66	return 0;
55	}	67	}
56		68
57	void radeon_gart_table_ram_free(struct radeon_device *rdev)	69	void radeon_gart_table_ram_free(struct radeon_device *rdev)
58	{	70	{
59	if (rdev->gart.table.ram.ptr == NULL) {	71	if (rdev->gart.table.ram.ptr == NULL) {
60	return;	72	return;
61	}	73	}
62	#ifdef CONFIG_X86	74	#ifdef CONFIG_X86
63	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480 \|\|	75	if (rdev->family == CHIP_RS400 \|\| rdev->family == CHIP_RS480 \|\|
64	rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) {	76	rdev->family == CHIP_RS690 \|\| rdev->family == CHIP_RS740) {
65	set_memory_wb((unsigned long)rdev->gart.table.ram.ptr,	77	set_memory_wb((unsigned long)rdev->gart.table.ram.ptr,
66	rdev->gart.table_size >> PAGE_SHIFT);	78	rdev->gart.table_size >> PAGE_SHIFT);
67	}	79	}
68	#endif	80	#endif
69	// pci_free_consistent(rdev->pdev, rdev->gart.table_size,	81	// pci_free_consistent(rdev->pdev, rdev->gart.table_size,
70	// (void *)rdev->gart.table.ram.ptr,	82	// (void *)rdev->gart.table.ram.ptr,
71	// rdev->gart.table_addr);	83	// rdev->gart.table_addr);
72	rdev->gart.table.ram.ptr = NULL;	84	rdev->gart.table.ram.ptr = NULL;
73	rdev->gart.table_addr = 0;	85	rdev->gart.table_addr = 0;
74	}	86	}
75		87
76	int radeon_gart_table_vram_alloc(struct radeon_device *rdev)	88	int radeon_gart_table_vram_alloc(struct radeon_device *rdev)
77	{	89	{
78	int r;	90	int r;
79		91
80	if (rdev->gart.table.vram.robj == NULL) {	92	if (rdev->gart.table.vram.robj == NULL) {
81	r = radeon_bo_create(rdev, NULL, rdev->gart.table_size,	93	r = radeon_bo_create(rdev, NULL, rdev->gart.table_size,
82	true, RADEON_GEM_DOMAIN_VRAM,	94	true, RADEON_GEM_DOMAIN_VRAM,
83	&rdev->gart.table.vram.robj);	95	&rdev->gart.table.vram.robj);
84	if (r) {	96	if (r) {
85	return r;	97	return r;
86	}	98	}
87	}	99	}
88	return 0;	100	return 0;
89	}	101	}
90		102
91	int radeon_gart_table_vram_pin(struct radeon_device *rdev)	103	int radeon_gart_table_vram_pin(struct radeon_device *rdev)
92	{	104	{
93	uint64_t gpu_addr;	105	uint64_t gpu_addr;
94	int r;	106	int r;
95		107
96	r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);	108	r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
97	if (unlikely(r != 0))	109	if (unlikely(r != 0))
98	return r;	110	return r;
99	r = radeon_bo_pin(rdev->gart.table.vram.robj,	111	r = radeon_bo_pin(rdev->gart.table.vram.robj,
100	RADEON_GEM_DOMAIN_VRAM, &gpu_addr);	112	RADEON_GEM_DOMAIN_VRAM, &gpu_addr);
101	if (r) {	113	if (r) {
102	radeon_bo_unreserve(rdev->gart.table.vram.robj);	114	radeon_bo_unreserve(rdev->gart.table.vram.robj);
103	return r;	115	return r;
104	}	116	}
105	r = radeon_bo_kmap(rdev->gart.table.vram.robj,	117	r = radeon_bo_kmap(rdev->gart.table.vram.robj,
106	(void **)&rdev->gart.table.vram.ptr);	118	(void **)&rdev->gart.table.vram.ptr);
107	if (r)	119	if (r)
108	radeon_bo_unpin(rdev->gart.table.vram.robj);	120	radeon_bo_unpin(rdev->gart.table.vram.robj);
109	radeon_bo_unreserve(rdev->gart.table.vram.robj);	121	radeon_bo_unreserve(rdev->gart.table.vram.robj);
110	rdev->gart.table_addr = gpu_addr;	122	rdev->gart.table_addr = gpu_addr;
111	return r;	123	return r;
112	}	124	}
113		125
114	void radeon_gart_table_vram_free(struct radeon_device *rdev)	126	void radeon_gart_table_vram_free(struct radeon_device *rdev)
115	{	127	{
116	int r;	128	int r;
117		129
118	if (rdev->gart.table.vram.robj == NULL) {	130	if (rdev->gart.table.vram.robj == NULL) {
119	return;	131	return;
120	}	132	}
121	r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);	133	r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
122	if (likely(r == 0)) {	134	if (likely(r == 0)) {
123	radeon_bo_kunmap(rdev->gart.table.vram.robj);	135	radeon_bo_kunmap(rdev->gart.table.vram.robj);
124	radeon_bo_unpin(rdev->gart.table.vram.robj);	136	radeon_bo_unpin(rdev->gart.table.vram.robj);
125	radeon_bo_unreserve(rdev->gart.table.vram.robj);	137	radeon_bo_unreserve(rdev->gart.table.vram.robj);
126	}	138	}
127	radeon_bo_unref(&rdev->gart.table.vram.robj);	139	radeon_bo_unref(&rdev->gart.table.vram.robj);
128	}	140	}
129		141
130		142
131		143
132		144
133	/*	145	/*
134	* Common gart functions.	146	* Common gart functions.
135	*/	147	*/
136	void radeon_gart_unbind(struct radeon_device *rdev, unsigned offset,	148	void radeon_gart_unbind(struct radeon_device *rdev, unsigned offset,
137	int pages)	149	int pages)
138	{	150	{
139	unsigned t;	151	unsigned t;
140	unsigned p;	152	unsigned p;
141	int i, j;	153	int i, j;
142	u64 page_base;	154	u64 page_base;
143		155
144	if (!rdev->gart.ready) {	156	if (!rdev->gart.ready) {
145	WARN(1, "trying to unbind memory to unitialized GART !\n");	157	WARN(1, "trying to unbind memory to unitialized GART !\n");
146	return;	158	return;
147	}	159	}
148	t = offset / RADEON_GPU_PAGE_SIZE;	160	t = offset / RADEON_GPU_PAGE_SIZE;
149	p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);	161	p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);
150	for (i = 0; i < pages; i++, p++) {	162	for (i = 0; i < pages; i++, p++) {
151	if (rdev->gart.pages[p]) {	163	if (rdev->gart.pages[p]) {
152	// pci_unmap_page(rdev->pdev, rdev->gart.pages_addr[p],	164	// pci_unmap_page(rdev->pdev, rdev->gart.pages_addr[p],
153	// PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);	165	// PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
154	rdev->gart.pages[p] = NULL;	166	rdev->gart.pages[p] = NULL;
155	rdev->gart.pages_addr[p] = rdev->dummy_page.addr;	167	rdev->gart.pages_addr[p] = rdev->dummy_page.addr;
156	page_base = rdev->gart.pages_addr[p];	168	page_base = rdev->gart.pages_addr[p];
157	for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {	169	for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {
158	radeon_gart_set_page(rdev, t, page_base);	170	radeon_gart_set_page(rdev, t, page_base);
159	page_base += RADEON_GPU_PAGE_SIZE;	171	page_base += RADEON_GPU_PAGE_SIZE;
160	}	172	}
161	}	173	}
162	}	174	}
163	mb();	175	mb();
164	radeon_gart_tlb_flush(rdev);	176	radeon_gart_tlb_flush(rdev);
165	}	177	}
166		178
167	int radeon_gart_bind(struct radeon_device *rdev, unsigned offset,	179	int radeon_gart_bind(struct radeon_device *rdev, unsigned offset,
168	int pages, u32_t *pagelist)	180	int pages, u32_t *pagelist)
169	{	181	{
170	unsigned t;	182	unsigned t;
171	unsigned p;	183	unsigned p;
172	uint64_t page_base;	184	uint64_t page_base;
173	int i, j;	185	int i, j;
174		186
175	ENTER();	187	ENTER();
176		188
177	dbgprintf("offset %x pages %x list %x\n",	189	dbgprintf("offset %x pages %x list %x\n",
178	offset, pages, pagelist);	190	offset, pages, pagelist);
179		191
180	if (!rdev->gart.ready) {	192	if (!rdev->gart.ready) {
181	DRM_ERROR("trying to bind memory to unitialized GART !\n");	193	DRM_ERROR("trying to bind memory to unitialized GART !\n");
182	return -EINVAL;	194	return -EINVAL;
183	}	195	}
184	t = offset / RADEON_GPU_PAGE_SIZE;	196	t = offset / RADEON_GPU_PAGE_SIZE;
185	p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);	197	p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);
186		198
187	for (i = 0; i < pages; i++, p++) {	199	for (i = 0; i < pages; i++, p++) {
188	/* we need to support large memory configurations */	200	/* we need to support large memory configurations */
189	/* assume that unbind have already been call on the range */	201	/* assume that unbind have already been call on the range */
190		202
191	rdev->gart.pages_addr[p] = pagelist[i] & ~4095;	203	rdev->gart.pages_addr[p] = pagelist[i] & ~4095;
192		204
193		205
194	rdev->gart.pages[p] = pagelist[i];	206	rdev->gart.pages[p] = pagelist[i];
195	page_base = rdev->gart.pages_addr[p];	207	page_base = rdev->gart.pages_addr[p];
196	for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {	208	for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {
197	radeon_gart_set_page(rdev, t, page_base);	209	radeon_gart_set_page(rdev, t, page_base);
198	page_base += RADEON_GPU_PAGE_SIZE;	210	page_base += RADEON_GPU_PAGE_SIZE;
199	}	211	}
200	}	212	}
201	mb();	213	mb();
202	radeon_gart_tlb_flush(rdev);	214	radeon_gart_tlb_flush(rdev);
203	return 0;	215	return 0;
204	}	216	}
205		217
206	void radeon_gart_restore(struct radeon_device *rdev)	218	void radeon_gart_restore(struct radeon_device *rdev)
207	{	219	{
208	int i, j, t;	220	int i, j, t;
209	u64 page_base;	221	u64 page_base;
210		222
211	for (i = 0, t = 0; i < rdev->gart.num_cpu_pages; i++) {	223	for (i = 0, t = 0; i < rdev->gart.num_cpu_pages; i++) {
212	page_base = rdev->gart.pages_addr[i];	224	page_base = rdev->gart.pages_addr[i];
213	for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {	225	for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {
214	radeon_gart_set_page(rdev, t, page_base);	226	radeon_gart_set_page(rdev, t, page_base);
215	page_base += RADEON_GPU_PAGE_SIZE;	227	page_base += RADEON_GPU_PAGE_SIZE;
216	}	228	}
217	}	229	}
218	mb();	230	mb();
219	radeon_gart_tlb_flush(rdev);	231	radeon_gart_tlb_flush(rdev);
220	}	232	}
221		233
222	int radeon_gart_init(struct radeon_device *rdev)	234	int radeon_gart_init(struct radeon_device *rdev)
223	{	235	{
224	int r, i;	236	int r, i;
225		237
226	if (rdev->gart.pages) {	238	if (rdev->gart.pages) {
227	return 0;	239	return 0;
228	}	240	}
229	/* We need PAGE_SIZE >= RADEON_GPU_PAGE_SIZE */	241	/* We need PAGE_SIZE >= RADEON_GPU_PAGE_SIZE */
230	if (PAGE_SIZE < RADEON_GPU_PAGE_SIZE) {	242	if (PAGE_SIZE < RADEON_GPU_PAGE_SIZE) {
231	DRM_ERROR("Page size is smaller than GPU page size!\n");	243	DRM_ERROR("Page size is smaller than GPU page size!\n");
232	return -EINVAL;	244	return -EINVAL;
233	}	245	}
234	r = radeon_dummy_page_init(rdev);	246	r = radeon_dummy_page_init(rdev);
235	if (r)	247	if (r)
236	return r;	248	return r;
237	/* Compute table size */	249	/* Compute table size */
238	rdev->gart.num_cpu_pages = rdev->mc.gtt_size / PAGE_SIZE;	250	rdev->gart.num_cpu_pages = rdev->mc.gtt_size / PAGE_SIZE;
239	rdev->gart.num_gpu_pages = rdev->mc.gtt_size / RADEON_GPU_PAGE_SIZE;	251	rdev->gart.num_gpu_pages = rdev->mc.gtt_size / RADEON_GPU_PAGE_SIZE;
240	DRM_INFO("GART: num cpu pages %u, num gpu pages %u\n",	252	DRM_INFO("GART: num cpu pages %u, num gpu pages %u\n",
241	rdev->gart.num_cpu_pages, rdev->gart.num_gpu_pages);	253	rdev->gart.num_cpu_pages, rdev->gart.num_gpu_pages);
242	/* Allocate pages table */	254	/* Allocate pages table */
243	rdev->gart.pages = kzalloc(sizeof(void ) rdev->gart.num_cpu_pages,	255	rdev->gart.pages = kzalloc(sizeof(void ) rdev->gart.num_cpu_pages,
244	GFP_KERNEL);	256	GFP_KERNEL);
245	if (rdev->gart.pages == NULL) {	257	if (rdev->gart.pages == NULL) {
246	radeon_gart_fini(rdev);	258	radeon_gart_fini(rdev);
247	return -ENOMEM;	259	return -ENOMEM;
248	}	260	}
249	rdev->gart.pages_addr = kzalloc(sizeof(dma_addr_t) *	261	rdev->gart.pages_addr = kzalloc(sizeof(dma_addr_t) *
250	rdev->gart.num_cpu_pages, GFP_KERNEL);	262	rdev->gart.num_cpu_pages, GFP_KERNEL);
251	if (rdev->gart.pages_addr == NULL) {	263	if (rdev->gart.pages_addr == NULL) {
252	radeon_gart_fini(rdev);	264	radeon_gart_fini(rdev);
253	return -ENOMEM;	265	return -ENOMEM;
254	}	266	}
255	/* set GART entry to point to the dummy page by default */	267	/* set GART entry to point to the dummy page by default */
256	for (i = 0; i < rdev->gart.num_cpu_pages; i++) {	268	for (i = 0; i < rdev->gart.num_cpu_pages; i++) {
257	rdev->gart.pages_addr[i] = rdev->dummy_page.addr;	269	rdev->gart.pages_addr[i] = rdev->dummy_page.addr;
258	}	270	}
259	return 0;	271	return 0;
260	}	272	}
261		273
262	void radeon_gart_fini(struct radeon_device *rdev)	274	void radeon_gart_fini(struct radeon_device *rdev)
263	{	275	{
264	if (rdev->gart.pages && rdev->gart.pages_addr && rdev->gart.ready) {	276	if (rdev->gart.pages && rdev->gart.pages_addr && rdev->gart.ready) {
265	/* unbind pages */	277	/* unbind pages */
266	radeon_gart_unbind(rdev, 0, rdev->gart.num_cpu_pages);	278	radeon_gart_unbind(rdev, 0, rdev->gart.num_cpu_pages);
267	}	279	}
268	rdev->gart.ready = false;	280	rdev->gart.ready = false;
269	kfree(rdev->gart.pages);	281	kfree(rdev->gart.pages);
270	kfree(rdev->gart.pages_addr);	282	kfree(rdev->gart.pages_addr);
271	rdev->gart.pages = NULL;	283	rdev->gart.pages = NULL;
272	rdev->gart.pages_addr = NULL;	284	rdev->gart.pages_addr = NULL;
273	}	285	}
-		286
-		287

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/radeon_gart.c – Rev 1430 → 1631