1/* 2 * Copyright (c) 2006 QLogic, Corporation. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 33#include <linux/scatterlist.h> 34#include <linux/gfp.h> 35#include <rdma/ib_verbs.h> 36 37#include "ipath_verbs.h" 38 39#define BAD_DMA_ADDRESS ((u64) 0) 40 41/* 42 * The following functions implement driver specific replacements 43 * for the ib_dma_*() functions. 44 * 45 * These functions return kernel virtual addresses instead of 46 * device bus addresses since the driver uses the CPU to copy 47 * data instead of using hardware DMA. 48 */ 49 50static int ipath_mapping_error(struct ib_device *dev, u64 dma_addr) 51{ 52 return dma_addr == BAD_DMA_ADDRESS; 53} 54 55static u64 ipath_dma_map_single(struct ib_device *dev, 56 void *cpu_addr, size_t size, 57 enum dma_data_direction direction) 58{ 59 BUG_ON(!valid_dma_direction(direction)); 60 return (u64) cpu_addr; 61} 62 63static void ipath_dma_unmap_single(struct ib_device *dev, 64 u64 addr, size_t size, 65 enum dma_data_direction direction) 66{ 67 BUG_ON(!valid_dma_direction(direction)); 68} 69 70static u64 ipath_dma_map_page(struct ib_device *dev, 71 struct page *page, 72 unsigned long offset, 73 size_t size, 74 enum dma_data_direction direction) 75{ 76 u64 addr; 77 78 BUG_ON(!valid_dma_direction(direction)); 79 80 if (offset + size > PAGE_SIZE) { 81 addr = BAD_DMA_ADDRESS; 82 goto done; 83 } 84 85 addr = (u64) page_address(page); 86 if (addr) 87 addr += offset; 88 /* TODO: handle highmem pages */ 89 90done: 91 return addr; 92} 93 94static void ipath_dma_unmap_page(struct ib_device *dev, 95 u64 addr, size_t size, 96 enum dma_data_direction direction) 97{ 98 BUG_ON(!valid_dma_direction(direction)); 99} 100 101static int ipath_map_sg(struct ib_device *dev, struct scatterlist *sgl, 102 int nents, enum dma_data_direction direction) 103{ 104 struct scatterlist *sg; 105 u64 addr; 106 int i; 107 int ret = nents; 108 109 BUG_ON(!valid_dma_direction(direction)); 110 111 for_each_sg(sgl, sg, nents, i) { 112 addr = (u64) page_address(sg_page(sg)); 113 /* TODO: handle highmem pages */ 114 if (!addr) { 115 ret = 0; 116 break; 117 } 118 sg->dma_address = addr + sg->offset; 119#ifdef CONFIG_NEED_SG_DMA_LENGTH 120 sg->dma_length = sg->length; 121#endif 122 } 123 return ret; 124} 125 126static void ipath_unmap_sg(struct ib_device *dev, 127 struct scatterlist *sg, int nents, 128 enum dma_data_direction direction) 129{ 130 BUG_ON(!valid_dma_direction(direction)); 131} 132 133static void ipath_sync_single_for_cpu(struct ib_device *dev, 134 u64 addr, 135 size_t size, 136 enum dma_data_direction dir) 137{ 138} 139 140static void ipath_sync_single_for_device(struct ib_device *dev, 141 u64 addr, 142 size_t size, 143 enum dma_data_direction dir) 144{ 145} 146 147static void *ipath_dma_alloc_coherent(struct ib_device *dev, size_t size, 148 u64 *dma_handle, gfp_t flag) 149{ 150 struct page *p; 151 void *addr = NULL; 152 153 p = alloc_pages(flag, get_order(size)); 154 if (p) 155 addr = page_address(p); 156 if (dma_handle) 157 *dma_handle = (u64) addr; 158 return addr; 159} 160 161static void ipath_dma_free_coherent(struct ib_device *dev, size_t size, 162 void *cpu_addr, u64 dma_handle) 163{ 164 free_pages((unsigned long) cpu_addr, get_order(size)); 165} 166 167struct ib_dma_mapping_ops ipath_dma_mapping_ops = { 168 .mapping_error = ipath_mapping_error, 169 .map_single = ipath_dma_map_single, 170 .unmap_single = ipath_dma_unmap_single, 171 .map_page = ipath_dma_map_page, 172 .unmap_page = ipath_dma_unmap_page, 173 .map_sg = ipath_map_sg, 174 .unmap_sg = ipath_unmap_sg, 175 .sync_single_for_cpu = ipath_sync_single_for_cpu, 176 .sync_single_for_device = ipath_sync_single_for_device, 177 .alloc_coherent = ipath_dma_alloc_coherent, 178 .free_coherent = ipath_dma_free_coherent 179}; 180