iommu/dma: Merge the CMA and alloc_pages allocation paths

	bool coherent = dev_is_dma_coherent(dev);

	int ioprot = dma_info_to_prot(DMA_BIDIRECTIONAL, coherent, attrs);

	size_t iosize = size;

	struct page *page;

	struct page *page = NULL;

	void *addr;

	size = PAGE_ALIGN(size);

	    !(attrs & DMA_ATTR_FORCE_CONTIGUOUS))

		return iommu_dma_alloc_remap(dev, iosize, handle, gfp, attrs);

	if (!gfpflags_allow_blocking(gfp)) {

		/*

		 * In atomic context we can't remap anything, so we'll only

		 * get the virtually contiguous buffer we need by way of a

		 * physically contiguous allocation.

		 */

		if (coherent) {

			page = alloc_pages(gfp, get_order(size));

			addr = page ? page_address(page) : NULL;

		} else {

	if (!gfpflags_allow_blocking(gfp) && !coherent) {

		addr = dma_alloc_from_pool(size, &page, gfp);

		}

		if (!addr)

			return NULL;

		*handle = __iommu_dma_map(dev, page_to_phys(page), iosize,

					  ioprot);

		if (*handle == DMA_MAPPING_ERROR) {

			if (coherent)

				__free_pages(page, get_order(size));

			else

			dma_free_from_pool(addr, size);

			return NULL;

		}

		return addr;

	}

	if (gfpflags_allow_blocking(gfp))

		page = dma_alloc_from_contiguous(dev, size >> PAGE_SHIFT,

					 get_order(size), gfp & __GFP_NOWARN);

						 get_order(size),

						 gfp & __GFP_NOWARN);

	if (!page)

		page = alloc_pages(gfp, get_order(size));

	if (!page)

		return NULL;

out_unmap:

	__iommu_dma_unmap(dev, *handle, iosize);

out_free_pages:

	dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT);

	if (!dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT))

		__free_pages(page, get_order(size));

	return NULL;

}