History

drm/ttm: isolate dma data from ttm_tt V4

Move dma data to a superset ttm_dma_tt structure which herit from ttm_tt. This allow driver that don't use dma functionalities to not have to waste memory for it. V2 Rebase on top of no memory account changes (where/when is my delorean when i need it ?) V3 Make sure page list is initialized empty V4 typo/syntax fixes

Jerome Glisse committed 15 years ago

Commit 8e7e7051 parent 3230cfc9 files · +203 −156Browse files

Unified · Split

9 files
  1. drivers/gpu/drm/nouveau/nouveau_bo.c +10 −8
  2. drivers/gpu/drm/nouveau/nouveau_sgdma.c +14 −8
  3. drivers/gpu/drm/radeon/radeon_ttm.c +22 −21
  4. drivers/gpu/drm/ttm/ttm_page_alloc.c +56 −58
  5. drivers/gpu/drm/ttm/ttm_page_alloc_dma.c +19 −16
  6. drivers/gpu/drm/ttm/ttm_tt.c +49 −11
  7. drivers/gpu/drm/vmwgfx/vmwgfx_buffer.c +2 −0
  8. include/drm/ttm/ttm_bo_driver.h +29 −3
  9. include/drm/ttm/ttm_page_alloc.h +2 −31
drivers/gpu/drm/nouveau/nouveau_bo.c+10−8
@@ -1052,6 +1052,7 @@ nouveau_bo_fence(struct nouveau_bo *nvbo, struct nouveau_fence *fence) · 1051 unmodified lines
10521052 static int
10531053 nouveau_ttm_tt_populate(struct ttm_tt *ttm)
10541054 {
1055+ struct ttm_dma_tt *ttm_dma = (void *)ttm;
10551056 struct drm_nouveau_private *dev_priv;
10561057 struct drm_device *dev;
10571058 unsigned i;
@@ -1065,7 +1066,7 @@ nouveau_ttm_tt_populate(struct ttm_tt *ttm) · 7 unmodified lines
10651066
10661067 #ifdef CONFIG_SWIOTLB
10671068 if (swiotlb_nr_tbl()) {
1068− return ttm_dma_populate(ttm, dev->dev);
1069+ return ttm_dma_populate((void *)ttm, dev->dev);
10691070 }
10701071 #endif
10711072
@@ -1075,14 +1076,14 @@ nouveau_ttm_tt_populate(struct ttm_tt *ttm) · 3 unmodified lines
10751076 }
10761077
10771078 for (i = 0; i < ttm->num_pages; i++) {
1078− ttm->dma_address[i] = pci_map_page(dev->pdev, ttm->pages[i],
1079+ ttm_dma->dma_address[i] = pci_map_page(dev->pdev, ttm->pages[i],
10791080 0, PAGE_SIZE,
10801081 PCI_DMA_BIDIRECTIONAL);
1081− if (pci_dma_mapping_error(dev->pdev, ttm->dma_address[i])) {
1082+ if (pci_dma_mapping_error(dev->pdev, ttm_dma->dma_address[i])) {
10821083 while (--i) {
1083− pci_unmap_page(dev->pdev, ttm->dma_address[i],
1084+ pci_unmap_page(dev->pdev, ttm_dma->dma_address[i],
10841085 PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
1085− ttm->dma_address[i] = 0;
1086+ ttm_dma->dma_address[i] = 0;
10861087 }
10871088 ttm_pool_unpopulate(ttm);
10881089 return -EFAULT;
@@ -1094,6 +1095,7 @@ nouveau_ttm_tt_populate(struct ttm_tt *ttm) · 5 unmodified lines
10941095 static void
10951096 nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm)
10961097 {
1098+ struct ttm_dma_tt *ttm_dma = (void *)ttm;
10971099 struct drm_nouveau_private *dev_priv;
10981100 struct drm_device *dev;
10991101 unsigned i;
@@ -1103,14 +1105,14 @@ nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm) · 3 unmodified lines
11031105
11041106 #ifdef CONFIG_SWIOTLB
11051107 if (swiotlb_nr_tbl()) {
1106− ttm_dma_unpopulate(ttm, dev->dev);
1108+ ttm_dma_unpopulate((void *)ttm, dev->dev);
11071109 return;
11081110 }
11091111 #endif
11101112
11111113 for (i = 0; i < ttm->num_pages; i++) {
1112− if (ttm->dma_address[i]) {
1113− pci_unmap_page(dev->pdev, ttm->dma_address[i],
1114+ if (ttm_dma->dma_address[i]) {
1115+ pci_unmap_page(dev->pdev, ttm_dma->dma_address[i],
11141116 PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
11151117 }
11161118 }
drivers/gpu/drm/nouveau/nouveau_sgdma.c+14−8
@@ -8,7 +8,10 @@ · 7 unmodified lines
88 #define NV_CTXDMA_PAGE_MASK (NV_CTXDMA_PAGE_SIZE - 1)
99
1010 struct nouveau_sgdma_be {
11− struct ttm_tt ttm;
11+ /* this has to be the first field so populate/unpopulated in
12+ * nouve_bo.c works properly, otherwise have to move them here
13+ */
14+ struct ttm_dma_tt ttm;
1215 struct drm_device *dev;
1316 u64 offset;
1417 };
@@ -20,6 +23,7 @@ nouveau_sgdma_destroy(struct ttm_tt *ttm) · 5 unmodified lines
2023
2124 if (ttm) {
2225 NV_DEBUG(nvbe->dev, "\n");
26+ ttm_dma_tt_fini(&nvbe->ttm);
2327 kfree(nvbe);
2428 }
2529 }
@@ -38,7 +42,7 @@ nv04_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem) · 12 unmodified lines
3842 nvbe->offset = mem->start << PAGE_SHIFT;
3943 pte = (nvbe->offset >> NV_CTXDMA_PAGE_SHIFT) + 2;
4044 for (i = 0; i < ttm->num_pages; i++) {
41− dma_addr_t dma_offset = ttm->dma_address[i];
45+ dma_addr_t dma_offset = nvbe->ttm.dma_address[i];
4246 uint32_t offset_l = lower_32_bits(dma_offset);
4347
4448 for (j = 0; j < PAGE_SIZE / NV_CTXDMA_PAGE_SIZE; j++, pte++) {
@@ -97,7 +101,7 @@ nv41_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem) · 52 unmodified lines
97101 struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
98102 struct drm_nouveau_private *dev_priv = nvbe->dev->dev_private;
99103 struct nouveau_gpuobj *pgt = dev_priv->gart_info.sg_ctxdma;
100− dma_addr_t *list = ttm->dma_address;
104+ dma_addr_t *list = nvbe->ttm.dma_address;
101105 u32 pte = mem->start << 2;
102106 u32 cnt = ttm->num_pages;
103107
@@ -206,7 +210,7 @@ nv44_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem) · 102 unmodified lines
206210 struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
207211 struct drm_nouveau_private *dev_priv = nvbe->dev->dev_private;
208212 struct nouveau_gpuobj *pgt = dev_priv->gart_info.sg_ctxdma;
209− dma_addr_t *list = ttm->dma_address;
213+ dma_addr_t *list = nvbe->ttm.dma_address;
210214 u32 pte = mem->start << 2, tmp[4];
211215 u32 cnt = ttm->num_pages;
212216 int i;
@@ -282,10 +286,11 @@ static struct ttm_backend_func nv44_sgdma_backend = { · 69 unmodified lines
282286 static int
283287 nv50_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem)
284288 {
289+ struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
285290 struct nouveau_mem *node = mem->mm_node;
286291
287292 /* noop: bound in move_notify() */
288− node->pages = ttm->dma_address;
293+ node->pages = nvbe->ttm.dma_address;
289294 return 0;
290295 }
291296
@@ -316,12 +321,13 @@ nouveau_sgdma_create_ttm(struct ttm_bo_device *bdev, · 24 unmodified lines
316321 return NULL;
317322
318323 nvbe->dev = dev;
319− nvbe->ttm.func = dev_priv->gart_info.func;
324+ nvbe->ttm.ttm.func = dev_priv->gart_info.func;
320325
321− if (ttm_tt_init(&nvbe->ttm, bdev, size, page_flags, dummy_read_page)) {
326+ if (ttm_dma_tt_init(&nvbe->ttm, bdev, size, page_flags, dummy_read_page)) {
327+ kfree(nvbe);
322328 return NULL;
323329 }
324− return &nvbe->ttm;
330+ return &nvbe->ttm.ttm;
325331 }
326332
327333 int
drivers/gpu/drm/radeon/radeon_ttm.c+22−21
@@ -501,7 +501,7 @@ static bool radeon_sync_obj_signaled(void *sync_obj, void *sync_arg) · 500 unmodified lines
501501 * TTM backend functions.
502502 */
503503 struct radeon_ttm_tt {
504− struct ttm_tt ttm;
504+ struct ttm_dma_tt ttm;
505505 struct radeon_device *rdev;
506506 u64 offset;
507507 };
@@ -509,17 +509,16 @@ struct radeon_ttm_tt { · 1 unmodified line
509509 static int radeon_ttm_backend_bind(struct ttm_tt *ttm,
510510 struct ttm_mem_reg *bo_mem)
511511 {
512− struct radeon_ttm_tt *gtt;
512+ struct radeon_ttm_tt *gtt = (void*)ttm;
513513 int r;
514514
515− gtt = container_of(ttm, struct radeon_ttm_tt, ttm);
516515 gtt->offset = (unsigned long)(bo_mem->start << PAGE_SHIFT);
517516 if (!ttm->num_pages) {
518517 WARN(1, "nothing to bind %lu pages for mreg %p back %p!\n",
519518 ttm->num_pages, bo_mem, ttm);
520519 }
521520 r = radeon_gart_bind(gtt->rdev, gtt->offset,
522− ttm->num_pages, ttm->pages, ttm->dma_address);
521+ ttm->num_pages, ttm->pages, gtt->ttm.dma_address);
523522 if (r) {
524523 DRM_ERROR("failed to bind %lu pages at 0x%08X\n",
525524 ttm->num_pages, (unsigned)gtt->offset);
@@ -530,18 +529,17 @@ static int radeon_ttm_backend_bind(struct ttm_tt *ttm, · 4 unmodified lines
530529
531530 static int radeon_ttm_backend_unbind(struct ttm_tt *ttm)
532531 {
533− struct radeon_ttm_tt *gtt;
532+ struct radeon_ttm_tt *gtt = (void *)ttm;
534533
535− gtt = container_of(ttm, struct radeon_ttm_tt, ttm);
536534 radeon_gart_unbind(gtt->rdev, gtt->offset, ttm->num_pages);
537535 return 0;
538536 }
539537
540538 static void radeon_ttm_backend_destroy(struct ttm_tt *ttm)
541539 {
542− struct radeon_ttm_tt *gtt;
540+ struct radeon_ttm_tt *gtt = (void *)ttm;
543541
544− gtt = container_of(ttm, struct radeon_ttm_tt, ttm);
542+ ttm_dma_tt_fini(&gtt->ttm);
545543 kfree(gtt);
546544 }
547545
@@ -570,17 +568,19 @@ struct ttm_tt *radeon_ttm_tt_create(struct ttm_bo_device *bdev, · 22 unmodified lines
570568 if (gtt == NULL) {
571569 return NULL;
572570 }
573− gtt->ttm.func = &radeon_backend_func;
571+ gtt->ttm.ttm.func = &radeon_backend_func;
574572 gtt->rdev = rdev;
575− if (ttm_tt_init(&gtt->ttm, bdev, size, page_flags, dummy_read_page)) {
573+ if (ttm_dma_tt_init(&gtt->ttm, bdev, size, page_flags, dummy_read_page)) {
574+ kfree(gtt);
576575 return NULL;
577576 }
578− return &gtt->ttm;
577+ return &gtt->ttm.ttm;
579578 }
580579
581580 static int radeon_ttm_tt_populate(struct ttm_tt *ttm)
582581 {
583582 struct radeon_device *rdev;
583+ struct radeon_ttm_tt *gtt = (void *)ttm;
584584 unsigned i;
585585 int r;
586586
@@ -591,7 +591,7 @@ static int radeon_ttm_tt_populate(struct ttm_tt *ttm) · 4 unmodified lines
591591
592592 #ifdef CONFIG_SWIOTLB
593593 if (swiotlb_nr_tbl()) {
594− return ttm_dma_populate(ttm, rdev->dev);
594+ return ttm_dma_populate(&gtt->ttm, rdev->dev);
595595 }
596596 #endif
597597
@@ -601,14 +601,14 @@ static int radeon_ttm_tt_populate(struct ttm_tt *ttm) · 3 unmodified lines
601601 }
602602
603603 for (i = 0; i < ttm->num_pages; i++) {
604− ttm->dma_address[i] = pci_map_page(rdev->pdev, ttm->pages[i],
605− 0, PAGE_SIZE,
606− PCI_DMA_BIDIRECTIONAL);
607− if (pci_dma_mapping_error(rdev->pdev, ttm->dma_address[i])) {
604+ gtt->ttm.dma_address[i] = pci_map_page(rdev->pdev, ttm->pages[i],
605+ 0, PAGE_SIZE,
606+ PCI_DMA_BIDIRECTIONAL);
607+ if (pci_dma_mapping_error(rdev->pdev, gtt->ttm.dma_address[i])) {
608608 while (--i) {
609− pci_unmap_page(rdev->pdev, ttm->dma_address[i],
609+ pci_unmap_page(rdev->pdev, gtt->ttm.dma_address[i],
610610 PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
611− ttm->dma_address[i] = 0;
611+ gtt->ttm.dma_address[i] = 0;
612612 }
613613 ttm_pool_unpopulate(ttm);
614614 return -EFAULT;
@@ -620,20 +620,21 @@ static int radeon_ttm_tt_populate(struct ttm_tt *ttm) · 5 unmodified lines
620620 static void radeon_ttm_tt_unpopulate(struct ttm_tt *ttm)
621621 {
622622 struct radeon_device *rdev;
623+ struct radeon_ttm_tt *gtt = (void *)ttm;
623624 unsigned i;
624625
625626 rdev = radeon_get_rdev(ttm->bdev);
626627
627628 #ifdef CONFIG_SWIOTLB
628629 if (swiotlb_nr_tbl()) {
629− ttm_dma_unpopulate(ttm, rdev->dev);
630+ ttm_dma_unpopulate(&gtt->ttm, rdev->dev);
630631 return;
631632 }
632633 #endif
633634
634635 for (i = 0; i < ttm->num_pages; i++) {
635− if (ttm->dma_address[i]) {
636− pci_unmap_page(rdev->pdev, ttm->dma_address[i],
636+ if (gtt->ttm.dma_address[i]) {
637+ pci_unmap_page(rdev->pdev, gtt->ttm.dma_address[i],
637638 PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
638639 }
639640 }
drivers/gpu/drm/ttm/ttm_page_alloc.c+56−58
@@ -662,13 +662,61 @@ out: · 661 unmodified lines
662662 return count;
663663 }
664664
665+/* Put all pages in pages list to correct pool to wait for reuse */
666+static void ttm_put_pages(struct page **pages, unsigned npages, int flags,
667+ enum ttm_caching_state cstate)
668+{
669+ unsigned long irq_flags;
670+ struct ttm_page_pool *pool = ttm_get_pool(flags, cstate);
671+ unsigned i;
672+
673+ if (pool == NULL) {
674+ /* No pool for this memory type so free the pages */
675+ for (i = 0; i < npages; i++) {
676+ if (pages[i]) {
677+ if (page_count(pages[i]) != 1)
678+ printk(KERN_ERR TTM_PFX
679+ "Erroneous page count. "
680+ "Leaking pages.\n");
681+ __free_page(pages[i]);
682+ pages[i] = NULL;
683+ }
684+ }
685+ return;
686+ }
687+
688+ spin_lock_irqsave(&pool->lock, irq_flags);
689+ for (i = 0; i < npages; i++) {
690+ if (pages[i]) {
691+ if (page_count(pages[i]) != 1)
692+ printk(KERN_ERR TTM_PFX
693+ "Erroneous page count. "
694+ "Leaking pages.\n");
695+ list_add_tail(&pages[i]->lru, &pool->list);
696+ pages[i] = NULL;
697+ pool->npages++;
698+ }
699+ }
700+ /* Check that we don't go over the pool limit */
701+ npages = 0;
702+ if (pool->npages > _manager->options.max_size) {
703+ npages = pool->npages - _manager->options.max_size;
704+ /* free at least NUM_PAGES_TO_ALLOC number of pages
705+ * to reduce calls to set_memory_wb */
706+ if (npages < NUM_PAGES_TO_ALLOC)
707+ npages = NUM_PAGES_TO_ALLOC;
708+ }
709+ spin_unlock_irqrestore(&pool->lock, irq_flags);
710+ if (npages)
711+ ttm_page_pool_free(pool, npages);
712+}
713+
665714 /*
666715 * On success pages list will hold count number of correctly
667716 * cached pages.
668717 */
669−int ttm_get_pages(struct page **pages, int flags,
670− enum ttm_caching_state cstate, unsigned npages,
671− dma_addr_t *dma_address)
718+static int ttm_get_pages(struct page **pages, unsigned npages, int flags,
719+ enum ttm_caching_state cstate)
672720 {
673721 struct ttm_page_pool *pool = ttm_get_pool(flags, cstate);
674722 struct list_head plist;
@@ -736,7 +784,7 @@ int ttm_get_pages(struct page **pages, int flags, · 61 unmodified lines
736784 printk(KERN_ERR TTM_PFX
737785 "Failed to allocate extra pages "
738786 "for large request.");
739− ttm_put_pages(pages, count, flags, cstate, NULL);
787+ ttm_put_pages(pages, count, flags, cstate);
740788 return r;
741789 }
742790 }
@@ -744,55 +792,6 @@ int ttm_get_pages(struct page **pages, int flags, · 1 unmodified line
744792 return 0;
745793 }
746794
747−/* Put all pages in pages list to correct pool to wait for reuse */
748−void ttm_put_pages(struct page **pages, unsigned npages, int flags,
749− enum ttm_caching_state cstate, dma_addr_t *dma_address)
750−{
751− unsigned long irq_flags;
752− struct ttm_page_pool *pool = ttm_get_pool(flags, cstate);
753− unsigned i;
754−
755− if (pool == NULL) {
756− /* No pool for this memory type so free the pages */
757− for (i = 0; i < npages; i++) {
758− if (pages[i]) {
759− if (page_count(pages[i]) != 1)
760− printk(KERN_ERR TTM_PFX
761− "Erroneous page count. "
762− "Leaking pages.\n");
763− __free_page(pages[i]);
764− pages[i] = NULL;
765− }
766− }
767− return;
768− }
769−
770− spin_lock_irqsave(&pool->lock, irq_flags);
771− for (i = 0; i < npages; i++) {
772− if (pages[i]) {
773− if (page_count(pages[i]) != 1)
774− printk(KERN_ERR TTM_PFX
775− "Erroneous page count. "
776− "Leaking pages.\n");
777− list_add_tail(&pages[i]->lru, &pool->list);
778− pages[i] = NULL;
779− pool->npages++;
780− }
781− }
782− /* Check that we don't go over the pool limit */
783− npages = 0;
784− if (pool->npages > _manager->options.max_size) {
785− npages = pool->npages - _manager->options.max_size;
786− /* free at least NUM_PAGES_TO_ALLOC number of pages
787− * to reduce calls to set_memory_wb */
788− if (npages < NUM_PAGES_TO_ALLOC)
789− npages = NUM_PAGES_TO_ALLOC;
790− }
791− spin_unlock_irqrestore(&pool->lock, irq_flags);
792− if (npages)
793− ttm_page_pool_free(pool, npages);
794−}
795−
796795 static void ttm_page_pool_init_locked(struct ttm_page_pool *pool, int flags,
797796 char *name)
798797 {
@@ -865,9 +864,9 @@ int ttm_pool_populate(struct ttm_tt *ttm) · 66 unmodified lines
865864 return 0;
866865
867866 for (i = 0; i < ttm->num_pages; ++i) {
868− ret = ttm_get_pages(&ttm->pages[i], ttm->page_flags,
869− ttm->caching_state, 1,
870− &ttm->dma_address[i]);
867+ ret = ttm_get_pages(&ttm->pages[i], 1,
868+ ttm->page_flags,
869+ ttm->caching_state);
871870 if (ret != 0) {
872871 ttm_pool_unpopulate(ttm);
873872 return -ENOMEM;
@@ -904,8 +903,7 @@ void ttm_pool_unpopulate(struct ttm_tt *ttm) · 30 unmodified lines
904903 ttm->pages[i]);
905904 ttm_put_pages(&ttm->pages[i], 1,
906905 ttm->page_flags,
907− ttm->caching_state,
908− ttm->dma_address);
906+ ttm->caching_state);
909907 }
910908 }
911909 ttm->state = tt_unpopulated;
drivers/gpu/drm/ttm/ttm_page_alloc_dma.c+19−16
@@ -789,7 +789,7 @@ out: · 788 unmodified lines
789789
790790 /*
791791 * @return count of pages still required to fulfill the request.
792−*/
792+ */
793793 static int ttm_dma_page_pool_fill_locked(struct dma_pool *pool,
794794 unsigned long *irq_flags)
795795 {
@@ -838,10 +838,11 @@ static int ttm_dma_page_pool_fill_locked(struct dma_pool *pool, · 42 unmodified lines
838838 * allocates one page at a time.
839839 */
840840 static int ttm_dma_pool_get_pages(struct dma_pool *pool,
841− struct ttm_tt *ttm,
841+ struct ttm_dma_tt *ttm_dma,
842842 unsigned index)
843843 {
844844 struct dma_page *d_page;
845+ struct ttm_tt *ttm = &ttm_dma->ttm;
845846 unsigned long irq_flags;
846847 int count, r = -ENOMEM;
847848
@@ -850,8 +851,8 @@ static int ttm_dma_pool_get_pages(struct dma_pool *pool, · 2 unmodified lines
850851 if (count) {
851852 d_page = list_first_entry(&pool->free_list, struct dma_page, page_list);
852853 ttm->pages[index] = d_page->p;
853− ttm->dma_address[index] = d_page->dma;
854− list_move_tail(&d_page->page_list, &ttm->alloc_list);
854+ ttm_dma->dma_address[index] = d_page->dma;
855+ list_move_tail(&d_page->page_list, &ttm_dma->pages_list);
855856 r = 0;
856857 pool->npages_in_use += 1;
857858 pool->npages_free -= 1;
@@ -864,8 +865,9 @@ static int ttm_dma_pool_get_pages(struct dma_pool *pool, · 6 unmodified lines
864865 * On success pages list will hold count number of correctly
865866 * cached pages. On failure will hold the negative return value (-ENOMEM, etc).
866867 */
867−int ttm_dma_populate(struct ttm_tt *ttm, struct device *dev)
868+int ttm_dma_populate(struct ttm_dma_tt *ttm_dma, struct device *dev)
868869 {
870+ struct ttm_tt *ttm = &ttm_dma->ttm;
869871 struct ttm_mem_global *mem_glob = ttm->glob->mem_glob;
870872 struct dma_pool *pool;
871873 enum pool_type type;
@@ -892,18 +894,18 @@ int ttm_dma_populate(struct ttm_tt *ttm, struct device *dev) · 20 unmodified lines
892894 }
893895 }
894896
895− INIT_LIST_HEAD(&ttm->alloc_list);
897+ INIT_LIST_HEAD(&ttm_dma->pages_list);
896898 for (i = 0; i < ttm->num_pages; ++i) {
897− ret = ttm_dma_pool_get_pages(pool, ttm, i);
899+ ret = ttm_dma_pool_get_pages(pool, ttm_dma, i);
898900 if (ret != 0) {
899− ttm_dma_unpopulate(ttm, dev);
901+ ttm_dma_unpopulate(ttm_dma, dev);
900902 return -ENOMEM;
901903 }
902904
903905 ret = ttm_mem_global_alloc_page(mem_glob, ttm->pages[i],
904906 false, false);
905907 if (unlikely(ret != 0)) {
906− ttm_dma_unpopulate(ttm, dev);
908+ ttm_dma_unpopulate(ttm_dma, dev);
907909 return -ENOMEM;
908910 }
909911 }
@@ -911,7 +913,7 @@ int ttm_dma_populate(struct ttm_tt *ttm, struct device *dev) · 1 unmodified line
911913 if (unlikely(ttm->page_flags & TTM_PAGE_FLAG_SWAPPED)) {
912914 ret = ttm_tt_swapin(ttm);
913915 if (unlikely(ret != 0)) {
914− ttm_dma_unpopulate(ttm, dev);
916+ ttm_dma_unpopulate(ttm_dma, dev);
915917 return ret;
916918 }
917919 }
@@ -937,8 +939,9 @@ static int ttm_dma_pool_get_num_unused_pages(void) · 19 unmodified lines
937939 }
938940
939941 /* Put all pages in pages list to correct pool to wait for reuse */
940−void ttm_dma_unpopulate(struct ttm_tt *ttm, struct device *dev)
942+void ttm_dma_unpopulate(struct ttm_dma_tt *ttm_dma, struct device *dev)
941943 {
944+ struct ttm_tt *ttm = &ttm_dma->ttm;
942945 struct dma_pool *pool;
943946 struct dma_page *d_page, *next;
944947 enum pool_type type;
@@ -956,7 +959,7 @@ void ttm_dma_unpopulate(struct ttm_tt *ttm, struct device *dev) · 11 unmodified lines
956959 ttm_to_type(ttm->page_flags, tt_cached)) == pool);
957960
958961 /* make sure pages array match list and count number of pages */
959− list_for_each_entry(d_page, &ttm->alloc_list, page_list) {
962+ list_for_each_entry(d_page, &ttm_dma->pages_list, page_list) {
960963 ttm->pages[count] = d_page->p;
961964 count++;
962965 }
@@ -967,7 +970,7 @@ void ttm_dma_unpopulate(struct ttm_tt *ttm, struct device *dev) · 4 unmodified lines
967970 pool->nfrees += count;
968971 } else {
969972 pool->npages_free += count;
970− list_splice(&ttm->alloc_list, &pool->free_list);
973+ list_splice(&ttm_dma->pages_list, &pool->free_list);
971974 if (pool->npages_free > _manager->options.max_size) {
972975 count = pool->npages_free - _manager->options.max_size;
973976 }
@@ -975,7 +978,7 @@ void ttm_dma_unpopulate(struct ttm_tt *ttm, struct device *dev) · 1 unmodified line
975978 spin_unlock_irqrestore(&pool->lock, irq_flags);
976979
977980 if (is_cached) {
978− list_for_each_entry_safe(d_page, next, &ttm->alloc_list, page_list) {
981+ list_for_each_entry_safe(d_page, next, &ttm_dma->pages_list, page_list) {
979982 ttm_mem_global_free_page(ttm->glob->mem_glob,
980983 d_page->p);
981984 ttm_dma_page_put(pool, d_page);
@@ -987,10 +990,10 @@ void ttm_dma_unpopulate(struct ttm_tt *ttm, struct device *dev) · 5 unmodified lines
987990 }
988991 }
989992
990− INIT_LIST_HEAD(&ttm->alloc_list);
993+ INIT_LIST_HEAD(&ttm_dma->pages_list);
991994 for (i = 0; i < ttm->num_pages; i++) {
992995 ttm->pages[i] = NULL;
993− ttm->dma_address[i] = 0;
996+ ttm_dma->dma_address[i] = 0;
994997 }
995998
996999 /* shrink pool if necessary */
drivers/gpu/drm/ttm/ttm_tt.c+49−11
@@ -48,17 +48,14 @@ · 47 unmodified lines
4848 */
4949 static void ttm_tt_alloc_page_directory(struct ttm_tt *ttm)
5050 {
51− ttm->pages = drm_calloc_large(ttm->num_pages, sizeof(*ttm->pages));
52− ttm->dma_address = drm_calloc_large(ttm->num_pages,
53− sizeof(*ttm->dma_address));
51+ ttm->pages = drm_calloc_large(ttm->num_pages, sizeof(void*));
5452 }
5553
56−static void ttm_tt_free_page_directory(struct ttm_tt *ttm)
54+static void ttm_dma_tt_alloc_page_directory(struct ttm_dma_tt *ttm)
5755 {
58− drm_free_large(ttm->pages);
59− ttm->pages = NULL;
60− drm_free_large(ttm->dma_address);
61− ttm->dma_address = NULL;
56+ ttm->ttm.pages = drm_calloc_large(ttm->ttm.num_pages, sizeof(void*));
57+ ttm->dma_address = drm_calloc_large(ttm->ttm.num_pages,
58+ sizeof(*ttm->dma_address));
6259 }
6360
6461 #ifdef CONFIG_X86
@@ -173,7 +170,6 @@ void ttm_tt_destroy(struct ttm_tt *ttm) · 108 unmodified lines
173170
174171 if (likely(ttm->pages != NULL)) {
175172 ttm->bdev->driver->ttm_tt_unpopulate(ttm);
176− ttm_tt_free_page_directory(ttm);
177173 }
178174
179175 if (!(ttm->page_flags & TTM_PAGE_FLAG_PERSISTENT_SWAP) &&
@@ -196,9 +192,8 @@ int ttm_tt_init(struct ttm_tt *ttm, struct ttm_bo_device *bdev, · 16 unmodified lines
196192 ttm->dummy_read_page = dummy_read_page;
197193 ttm->state = tt_unpopulated;
198194
199− INIT_LIST_HEAD(&ttm->alloc_list);
200195 ttm_tt_alloc_page_directory(ttm);
201− if (!ttm->pages || !ttm->dma_address) {
196+ if (!ttm->pages) {
202197 ttm_tt_destroy(ttm);
203198 printk(KERN_ERR TTM_PFX "Failed allocating page table\n");
204199 return -ENOMEM;
@@ -207,6 +202,49 @@ int ttm_tt_init(struct ttm_tt *ttm, struct ttm_bo_device *bdev, · 2 unmodified lines
207202 }
208203 EXPORT_SYMBOL(ttm_tt_init);
209204
205+void ttm_tt_fini(struct ttm_tt *ttm)
206+{
207+ drm_free_large(ttm->pages);
208+ ttm->pages = NULL;
209+}
210+EXPORT_SYMBOL(ttm_tt_fini);
211+
212+int ttm_dma_tt_init(struct ttm_dma_tt *ttm_dma, struct ttm_bo_device *bdev,
213+ unsigned long size, uint32_t page_flags,
214+ struct page *dummy_read_page)
215+{
216+ struct ttm_tt *ttm = &ttm_dma->ttm;
217+
218+ ttm->bdev = bdev;
219+ ttm->glob = bdev->glob;
220+ ttm->num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
221+ ttm->caching_state = tt_cached;
222+ ttm->page_flags = page_flags;
223+ ttm->dummy_read_page = dummy_read_page;
224+ ttm->state = tt_unpopulated;
225+
226+ INIT_LIST_HEAD(&ttm_dma->pages_list);
227+ ttm_dma_tt_alloc_page_directory(ttm_dma);
228+ if (!ttm->pages || !ttm_dma->dma_address) {
229+ ttm_tt_destroy(ttm);
230+ printk(KERN_ERR TTM_PFX "Failed allocating page table\n");
231+ return -ENOMEM;
232+ }
233+ return 0;
234+}
235+EXPORT_SYMBOL(ttm_dma_tt_init);
236+
237+void ttm_dma_tt_fini(struct ttm_dma_tt *ttm_dma)
238+{
239+ struct ttm_tt *ttm = &ttm_dma->ttm;
240+
241+ drm_free_large(ttm->pages);
242+ ttm->pages = NULL;
243+ drm_free_large(ttm_dma->dma_address);
244+ ttm_dma->dma_address = NULL;
245+}
246+EXPORT_SYMBOL(ttm_dma_tt_fini);
247+
210248 void ttm_tt_unbind(struct ttm_tt *ttm)
211249 {
212250 int ret;
drivers/gpu/drm/vmwgfx/vmwgfx_buffer.c+2−0
@@ -168,6 +168,7 @@ static void vmw_ttm_destroy(struct ttm_tt *ttm) · 167 unmodified lines
168168 {
169169 struct vmw_ttm_tt *vmw_be = container_of(ttm, struct vmw_ttm_tt, ttm);
170170
171+ ttm_tt_fini(ttm);
171172 kfree(vmw_be);
172173 }
173174
@@ -191,6 +192,7 @@ struct ttm_tt *vmw_ttm_tt_create(struct ttm_bo_device *bdev, · 17 unmodified lines
191192 vmw_be->dev_priv = container_of(bdev, struct vmw_private, bdev);
192193
193194 if (ttm_tt_init(&vmw_be->ttm, bdev, size, page_flags, dummy_read_page)) {
195+ kfree(vmw_be);
194196 return NULL;
195197 }
196198
include/drm/ttm/ttm_bo_driver.h+29−3
@@ -103,8 +103,6 @@ enum ttm_caching_state { · 102 unmodified lines
103103 * @swap_storage: Pointer to shmem struct file for swap storage.
104104 * @caching_state: The current caching state of the pages.
105105 * @state: The current binding state of the pages.
106− * @dma_address: The DMA (bus) addresses of the pages (if TTM_PAGE_FLAG_DMA32)
107− * @alloc_list: used by some page allocation backend
108106 *
109107 * This is a structure holding the pages, caching- and aperture binding
110108 * status for a buffer object that isn't backed by fixed (VRAM / AGP)
@@ -127,8 +125,23 @@ struct ttm_tt { · 16 unmodified lines
127125 tt_unbound,
128126 tt_unpopulated,
129127 } state;
128+};
129+
130+/**
131+ * struct ttm_dma_tt
132+ *
133+ * @ttm: Base ttm_tt struct.
134+ * @dma_address: The DMA (bus) addresses of the pages
135+ * @pages_list: used by some page allocation backend
136+ *
137+ * This is a structure holding the pages, caching- and aperture binding
138+ * status for a buffer object that isn't backed by fixed (VRAM / AGP)
139+ * memory.
140+ */
141+struct ttm_dma_tt {
142+ struct ttm_tt ttm;
130143 dma_addr_t *dma_address;
131− struct list_head alloc_list;
144+ struct list_head pages_list;
132145 };
133146
134147 #define TTM_MEMTYPE_FLAG_FIXED (1 << 0) /* Fixed (on-card) PCI memory */
@@ -595,6 +608,19 @@ ttm_flag_masked(uint32_t *old, uint32_t new, uint32_t mask) · 460 unmodified lines
595608 extern int ttm_tt_init(struct ttm_tt *ttm, struct ttm_bo_device *bdev,
596609 unsigned long size, uint32_t page_flags,
597610 struct page *dummy_read_page);
611+extern int ttm_dma_tt_init(struct ttm_dma_tt *ttm_dma, struct ttm_bo_device *bdev,
612+ unsigned long size, uint32_t page_flags,
613+ struct page *dummy_read_page);
614+
615+/**
616+ * ttm_tt_fini
617+ *
618+ * @ttm: the ttm_tt structure.
619+ *
620+ * Free memory of ttm_tt structure
621+ */
622+extern void ttm_tt_fini(struct ttm_tt *ttm);
623+extern void ttm_dma_tt_fini(struct ttm_dma_tt *ttm_dma);
598624
599625 /**
600626 * ttm_ttm_bind:
include/drm/ttm/ttm_page_alloc.h+2−31
@@ -29,35 +29,6 @@ · 28 unmodified lines
2929 #include "ttm_bo_driver.h"
3030 #include "ttm_memory.h"
3131
32−/**
33− * Get count number of pages from pool to pages list.
34− *
35− * @pages: head of empty linked list where pages are filled.
36− * @flags: ttm flags for page allocation.
37− * @cstate: ttm caching state for the page.
38− * @count: number of pages to allocate.
39− * @dma_address: The DMA (bus) address of pages (if TTM_PAGE_FLAG_DMA32 set).
40− */
41−int ttm_get_pages(struct page **pages,
42− int flags,
43− enum ttm_caching_state cstate,
44− unsigned npages,
45− dma_addr_t *dma_address);
46−/**
47− * Put linked list of pages to pool.
48− *
49− * @pages: list of pages to free.
50− * @page_count: number of pages in the list. Zero can be passed for unknown
51− * count.
52− * @flags: ttm flags for page allocation.
53− * @cstate: ttm caching state.
54− * @dma_address: The DMA (bus) address of pages (if TTM_PAGE_FLAG_DMA32 set).
55− */
56−void ttm_put_pages(struct page **pages,
57− unsigned npages,
58− int flags,
59− enum ttm_caching_state cstate,
60− dma_addr_t *dma_address);
6132 /**
6233 * Initialize pool allocator.
6334 */
@@ -107,8 +78,8 @@ void ttm_dma_page_alloc_fini(void); · 43 unmodified lines
10778 */
10879 extern int ttm_dma_page_alloc_debugfs(struct seq_file *m, void *data);
10980
110−int ttm_dma_populate(struct ttm_tt *ttm, struct device *dev);
111−extern void ttm_dma_unpopulate(struct ttm_tt *ttm, struct device *dev);
81+extern int ttm_dma_populate(struct ttm_dma_tt *ttm_dma, struct device *dev);
82+extern void ttm_dma_unpopulate(struct ttm_dma_tt *ttm_dma, struct device *dev);
11283
11384 #else
11485 static inline int ttm_dma_page_alloc_init(struct ttm_mem_global *glob,