1/* 2 * Copyright (c) 2006, 2009, 2010 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#include <linux/types.h> 33#include <linux/scatterlist.h> 34 35#include "qib_verbs.h" 36 37#define BAD_DMA_ADDRESS ((u64) 0) 38 39/* 40 * The following functions implement driver specific replacements 41 * for the ib_dma_*() functions. 42 * 43 * These functions return kernel virtual addresses instead of 44 * device bus addresses since the driver uses the CPU to copy 45 * data instead of using hardware DMA. 46 */ 47 48static int qib_mapping_error(struct ib_device *dev, u64 dma_addr) 49{ 50 return dma_addr == BAD_DMA_ADDRESS; 51} 52 53static u64 qib_dma_map_single(struct ib_device *dev, void *cpu_addr, 54 size_t size, enum dma_data_direction direction) 55{ 56 BUG_ON(!valid_dma_direction(direction)); 57 return (u64) cpu_addr; 58} 59 60static void qib_dma_unmap_single(struct ib_device *dev, u64 addr, size_t size, 61 enum dma_data_direction direction) 62{ 63 BUG_ON(!valid_dma_direction(direction)); 64} 65 66static u64 qib_dma_map_page(struct ib_device *dev, struct page *page, 67 unsigned long offset, size_t size, 68 enum dma_data_direction direction) 69{ 70 u64 addr; 71 72 BUG_ON(!valid_dma_direction(direction)); 73 74 if (offset + size > PAGE_SIZE) { 75 addr = BAD_DMA_ADDRESS; 76 goto done; 77 } 78 79 addr = (u64) page_address(page); 80 if (addr) 81 addr += offset; 82 /* TODO: handle highmem pages */ 83 84done: 85 return addr; 86} 87 88static void qib_dma_unmap_page(struct ib_device *dev, u64 addr, size_t size, 89 enum dma_data_direction direction) 90{ 91 BUG_ON(!valid_dma_direction(direction)); 92} 93 94static int qib_map_sg(struct ib_device *dev, struct scatterlist *sgl, 95 int nents, enum dma_data_direction direction) 96{ 97 struct scatterlist *sg; 98 u64 addr; 99 int i; 100 int ret = nents; 101 102 BUG_ON(!valid_dma_direction(direction)); 103 104 for_each_sg(sgl, sg, nents, i) { 105 addr = (u64) page_address(sg_page(sg)); 106 /* TODO: handle highmem pages */ 107 if (!addr) { 108 ret = 0; 109 break; 110 } 111 } 112 return ret; 113} 114 115static void qib_unmap_sg(struct ib_device *dev, 116 struct scatterlist *sg, int nents, 117 enum dma_data_direction direction) 118{ 119 BUG_ON(!valid_dma_direction(direction)); 120} 121 122static u64 qib_sg_dma_address(struct ib_device *dev, struct scatterlist *sg) 123{ 124 u64 addr = (u64) page_address(sg_page(sg)); 125 126 if (addr) 127 addr += sg->offset; 128 return addr; 129} 130 131static unsigned int qib_sg_dma_len(struct ib_device *dev, 132 struct scatterlist *sg) 133{ 134 return sg->length; 135} 136 137static void qib_sync_single_for_cpu(struct ib_device *dev, u64 addr, 138 size_t size, enum dma_data_direction dir) 139{ 140} 141 142static void qib_sync_single_for_device(struct ib_device *dev, u64 addr, 143 size_t size, 144 enum dma_data_direction dir) 145{ 146} 147 148static void *qib_dma_alloc_coherent(struct ib_device *dev, size_t size, 149 u64 *dma_handle, gfp_t flag) 150{ 151 struct page *p; 152 void *addr = NULL; 153 154 p = alloc_pages(flag, get_order(size)); 155 if (p) 156 addr = page_address(p); 157 if (dma_handle) 158 *dma_handle = (u64) addr; 159 return addr; 160} 161 162static void qib_dma_free_coherent(struct ib_device *dev, size_t size, 163 void *cpu_addr, u64 dma_handle) 164{ 165 free_pages((unsigned long) cpu_addr, get_order(size)); 166} 167 168struct ib_dma_mapping_ops qib_dma_mapping_ops = { 169 .mapping_error = qib_mapping_error, 170 .map_single = qib_dma_map_single, 171 .unmap_single = qib_dma_unmap_single, 172 .map_page = qib_dma_map_page, 173 .unmap_page = qib_dma_unmap_page, 174 .map_sg = qib_map_sg, 175 .unmap_sg = qib_unmap_sg, 176 .dma_address = qib_sg_dma_address, 177 .dma_len = qib_sg_dma_len, 178 .sync_single_for_cpu = qib_sync_single_for_cpu, 179 .sync_single_for_device = qib_sync_single_for_device, 180 .alloc_coherent = qib_dma_alloc_coherent, 181 .free_coherent = qib_dma_free_coherent 182}; 183