New subject: [PATCH 01/13] swiotlb: Expose swiotlb_nr_tlb function to modules

11 Nov 2011

struct list_head *pages, int ttm_flags,

enum ttm_caching_state cstate, unsigned count)

			struct list_head *pages,

			int ttm_flags,

			enum ttm_caching_state cstate,

			unsigned count)

  enum ttm_caching_state cstate, unsigned count,

  enum ttm_caching_state cstate, unsigned npages,

for (r = 0; r<  count; ++r) {

for (r = 0; r<  npages; ++r) {
p = alloc_page(gfp_flags);
if (!p) {

	list_add(&p->lru, pages);

	pages[r] = p;

pages[count++] = p;

list_for_each_entry(p, pages, lru) {

list_for_each_entry(p,&plist, lru) {
clear_page(page_address(p));

r = ttm_alloc_new_pages(pages, gfp_flags, flags, cstate, count);

INIT_LIST_HEAD(&plist);

r = ttm_alloc_new_pages(&plist, gfp_flags, flags, cstate, npages);

list_for_each_entry(p,&plist, lru) {

	pages[count++] = p;

}

	ttm_put_pages(pages, 0, flags, cstate, NULL);

	ttm_put_pages(pages, count, flags, cstate, NULL);
return r;

list_for_each_entry_safe(p, tmp, pages, lru) {

	__free_page(p);

for (i = 0; i<  npages; i++) {

	if (pages[i]) {

		if (page_count(pages[i]) != 1)

			printk(KERN_ERR TTM_PFX

			       "Erroneous page count. "

			       "Leaking pages.\n");

		__free_page(pages[i]);

		pages[i] = NULL;

	}

/* Make the pages list empty */

INIT_LIST_HEAD(pages);

list_for_each_entry_safe(p, tmp, pages, lru) {

	++page_count;

}

if (pages[i]) {

	if (page_count(pages[i]) != 1)

		printk(KERN_ERR TTM_PFX

		       "Erroneous page count. "

		       "Leaking pages.\n");

	list_add_tail(&pages[i]->lru,&pool->list);

	pages[i] = NULL;

	pool->npages++;

}

page_count = pool->npages - _manager->options.max_size;

npages = pool->npages - _manager->options.max_size;

if (page_count<  NUM_PAGES_TO_ALLOC)

	page_count = NUM_PAGES_TO_ALLOC;

if (npages<  NUM_PAGES_TO_ALLOC)

	npages = NUM_PAGES_TO_ALLOC;

ttm_page_pool_free(pool, page_count);

ttm_page_pool_free(pool, npages);

INIT_LIST_HEAD(&h);

ret = ttm_get_pages(&h, ttm->page_flags, ttm->caching_state, 1,

ret = ttm_get_pages(&p, ttm->page_flags, ttm->caching_state, 1,
	&ttm->dma_address[index]);

p = list_first_entry(&h, struct page, lru);

cur_page = ttm->pages[i];

ttm->pages[i] = NULL;

if (cur_page) {

	if (page_count(cur_page) != 1)

		printk(KERN_ERR TTM_PFX

		       "Erroneous page count. "

		       "Leaking pages.\n");

if (ttm->pages[i]) {
ttm_mem_global_free_page(ttm->glob->mem_glob,

				 cur_page);

	list_add(&cur_page->lru,&h);

	count++;

				 ttm->pages[i]);

	ttm_put_pages(&ttm->pages[i], 1, ttm->page_flags,

		      ttm->caching_state,&ttm->dma_address[i]);

      ttm->dma_address);

  unsigned count,

  unsigned npages,

   unsigned page_count,

   unsigned npages,

      unsigned long size, uint32_t page_flags,

      struct page *dummy_read_page)

return ttm_agp_backend_init(bdev, dev->agp->bridge);

return ttm_agp_tt_create(bdev, dev->agp->bridge,

			 size, page_flags, dummy_read_page);

return nouveau_sgdma_init_ttm(dev);

return nouveau_sgdma_create_ttm(bdev, size, page_flags,

				dummy_read_page);

			       unsigned long size,

			       uint32_t page_flags,

			       struct page *dummy_read_page);

       struct page **pages, struct page *dummy_read_page,

       dma_addr_t *dma_addrs)

nvbe->unmap_pages = false;

return 0;

nvbe->pages[i] = pci_map_page(dev->pdev, pages[i], 0,

			      PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

if (pci_dma_mapping_error(dev->pdev, nvbe->pages[i])) {

	nvbe->nr_pages = --i;

	be->func->clear(be);

ttm->dma_address[i] = pci_map_page(dev->pdev, ttm->pages[i],

				   0, PAGE_SIZE,

				   PCI_DMA_BIDIRECTIONAL);

if (pci_dma_mapping_error(dev->pdev, ttm->dma_address[i])) {
return -EFAULT;

be->func->unbind(be);

while (nvbe->nr_pages--) {

	pci_unmap_page(dev->pdev, nvbe->pages[nvbe->nr_pages],

if (ttm->dma_address[i]) {

	pci_unmap_page(dev->pdev, ttm->dma_address[i],
	       PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

ttm->dma_address[i] = 0;

if (nvbe) {

	if (nvbe->pages)

		be->func->clear(be);

	kfree(nvbe);

}

kfree(nvbe);

return r;

dma_addr_t dma_offset = nvbe->pages[i];

dma_addr_t dma_offset = ttm->dma_address[i];

return r;

return r;

return r;

	 unsigned long size, uint32_t page_flags,

	 struct page *dummy_read_page)

return NULL;

return ttm_agp_backend_init(bdev, rdev->ddev->agp->bridge);

return radeon_ttm_backend_create(rdev);

		   struct ttm_mem_reg *bo_mem)

WARN(1, "nothing to bind %lu pages for mreg %p back %p!\n",

     ttm->num_pages, bo_mem, ttm);

	     ttm->num_pages, ttm->pages, ttm->dma_address);

DRM_ERROR("failed to bind %lu pages at 0x%08X\n",

	  ttm->num_pages, (unsigned)gtt->offset);

return r;

radeon_ttm_backend_unbind(ttm);

		    unsigned long size, uint32_t page_flags,

		    struct page *dummy_read_page)

return ttm_agp_tt_create(bdev, rdev->ddev->agp->bridge,

			 size, page_flags, dummy_read_page);

return NULL;

return NULL;

		       unsigned long num_pages,

		       struct page **pages,

		       struct page *dummy_read_page,

		       dma_addr_t *dma_addrs)

		   struct ttm_mem_reg *bo_mem)

WARN(1, "nothing to bind %lu pages for mreg %p back %p!\n",

     gtt->num_pages, bo_mem, backend);

	     gtt->num_pages, gtt->pages, gtt->dma_addrs);

DRM_ERROR("failed to bind %lu pages at 0x%08X\n",

	  gtt->num_pages, gtt->offset);

return r;

radeon_ttm_backend_unbind(backend);

return NULL;

	    unsigned long num_pages, struct page **pages,

	    struct page *dummy_read_page,

	    dma_addr_t *dma_addrs)

   container_of(backend, struct ttm_agp_backend, backend);

struct page *page = *cur_page;

struct page *page = ttm->pages[i];

	page = dummy_read_page;

	page = ttm->dummy_read_page;

   container_of(backend, struct ttm_agp_backend, backend);

   container_of(backend, struct ttm_agp_backend, backend);

return agp_unbind_memory(agp_be->mem);

return 0;

   container_of(backend, struct ttm_agp_backend, backend);

ttm_agp_unbind(backend);

agp_free_memory(mem);

if (agp_be->mem->is_bound)

	return agp_unbind_memory(agp_be->mem);

agp_free_memory(agp_be->mem);

agp_be->mem = NULL;

   container_of(backend, struct ttm_agp_backend, backend);

ttm_agp_clear(backend);

ttm_agp_unbind(ttm);

			 struct agp_bridge_data *bridge)

		 struct agp_bridge_data *bridge,

		 unsigned long size, uint32_t page_flags,

		 struct page *dummy_read_page)

return NULL;

bo->ttm = ttm_tt_create(bdev, bo->num_pages<<  PAGE_SHIFT,

			page_flags, glob->dummy_read_page);

bo->ttm = bdev->driver->ttm_tt_create(bdev, bo->num_pages<<  PAGE_SHIFT,

				      page_flags, glob->dummy_read_page);

ttm_round_pot(sizeof(struct ttm_tt)) +

ttm_round_pot(sizeof(struct ttm_backend));

	   ttm->dummy_read_page, ttm->dma_address);

be->func->clear(be);

be->func->destroy(be);

ttm->be = NULL;

	     uint32_t page_flags, struct page *dummy_read_page)

unsigned long size, uint32_t page_flags,

struct page *dummy_read_page)

return NULL;

return NULL;

return NULL;

return -ENOMEM;

ttm_tt_destroy(ttm);

printk(KERN_ERR TTM_PFX "Failed creating ttm backend entry\n");

return NULL;

ret = be->func->unbind(be);

ret = ttm->func->unbind(ttm);

	    unsigned long num_pages, struct page **pages,

	    struct page *dummy_read_page,

	    dma_addr_t *dma_addrs)

   container_of(backend, struct vmw_ttm_backend, backend);

   container_of(backend, struct vmw_ttm_backend, backend);

	    vmw_be->num_pages, vmw_be->gmr_id);

	    ttm->num_pages, vmw_be->gmr_id);

   container_of(backend, struct vmw_ttm_backend, backend);

container_of(backend, struct vmw_ttm_backend, backend);

   container_of(backend, struct vmw_ttm_backend, backend);

		 unsigned long size, uint32_t page_flags,

		 struct page *dummy_read_page)

return NULL;

* struct ttm_backend_func member populate

*

* @backend: Pointer to a struct ttm_backend.

* @num_pages: Number of pages to populate.

* @pages: Array of pointers to ttm pages.

* @dummy_read_page: Page to be used instead of NULL pages in the

* array @pages.

* @dma_addrs: Array of DMA (bus) address of the ttm pages.

*

* Populate the backend with ttm pages. Depending on the backend,

* it may or may not copy the @pages array.

*/

	 unsigned long num_pages, struct page **pages,

	 struct page *dummy_read_page,

	 dma_addr_t *dma_addrs);

* struct ttm_backend_func member clear

*

* @backend: Pointer to a struct ttm_backend.

*

* This is an "unpopulate" function. Release all resources

* allocated with populate.

*/

* @backend: Pointer to a struct ttm_backend.

* @ttm: Pointer to a struct ttm_tt.

* @backend: Pointer to a struct ttm_backend.

* @ttm: Pointer to a struct ttm_tt.

* @backend: Pointer to a struct ttm_backend.

* @ttm: Pointer to a struct ttm_tt.

* Destroy the backend.

* Destroy the backend. This will be call back from ttm_tt_destroy so

* don't call ttm_tt_destroy from the callback or infinite loop.

* struct ttm_bo_driver member create_ttm_backend_entry

* ttm_tt_create

* @bdev: The buffer object device.

* @bdev: pointer to a struct ttm_bo_device:

* @size: Size of the data needed backing.

* @page_flags: Page flags as identified by TTM_PAGE_FLAG_XX flags.

* @dummy_read_page: See struct ttm_bo_device.

* Create a driver specific struct ttm_backend.

* Create a struct ttm_tt to back data with system memory pages.

* No pages are actually allocated.

* Returns:

* NULL: Out of memory.

(struct ttm_bo_device *bdev);

			unsigned long size,

			uint32_t page_flags,

			struct page *dummy_read_page);

		    unsigned long size,

		    uint32_t page_flags,

		    struct page *dummy_read_page);

	unsigned long size, uint32_t page_flags,

	struct page *dummy_read_page);

				struct agp_bridge_data *bridge);

			struct agp_bridge_data *bridge,

			unsigned long size, uint32_t page_flags,

			struct page *dummy_read_page);

ttm: merge ttm_backend & ttm_tt, introduce ttm dma allocator V4

Signed-off-by: Jerome Glissejglisse@redhat.com