drm: prime: use sgtable iterators in drm_prime_sg_to_page_addr_arrays()

int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,

				     dma_addr_t *addrs, int max_entries)

{

	unsigned count;

	struct scatterlist *sg;

	struct page *page;

	u32 page_len, page_index;

	dma_addr_t addr;

	u32 dma_len, dma_index;

	/*

	 * Scatterlist elements contains both pages and DMA addresses, but

	 * one shoud not assume 1:1 relation between them. The sg->length is

	 * the size of the physical memory chunk described by the sg->page,

	 * while sg_dma_len(sg) is the size of the DMA (IO virtual) chunk

	 * described by the sg_dma_address(sg).

	 */

	page_index = 0;

	dma_index = 0;

	for_each_sg(sgt->sgl, sg, sgt->nents, count) {

		page_len = sg->length;

		page = sg_page(sg);

		dma_len = sg_dma_len(sg);

		addr = sg_dma_address(sg);

		while (pages && page_len > 0) {

			if (WARN_ON(page_index >= max_entries))

	struct sg_dma_page_iter dma_iter;

	struct sg_page_iter page_iter;

	struct page **p = pages;

	dma_addr_t *a = addrs;

	if (pages) {

		for_each_sgtable_page(sgt, &page_iter, 0) {

			if (WARN_ON(p - pages >= max_entries))

				return -1;

			pages[page_index] = page;

			page++;

			page_len -= PAGE_SIZE;

			page_index++;

			*p++ = sg_page_iter_page(&page_iter);

		}

	}

		while (addrs && dma_len > 0) {

			if (WARN_ON(dma_index >= max_entries))

	if (addrs) {

		for_each_sgtable_dma_page(sgt, &dma_iter, 0) {

			if (WARN_ON(a - addrs >= max_entries))

				return -1;

			addrs[dma_index] = addr;

			addr += PAGE_SIZE;

			dma_len -= PAGE_SIZE;

			dma_index++;

			*a++ = sg_page_iter_dma_address(&dma_iter);

		}

	}

	return 0;

}

EXPORT_SYMBOL(drm_prime_sg_to_page_addr_arrays);