Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 1 | /* |
| 2 | * IBM eServer eHCA Infiniband device driver for Linux on POWER |
| 3 | * |
| 4 | * MR/MW functions |
| 5 | * |
| 6 | * Authors: Dietmar Decker <ddecker@de.ibm.com> |
| 7 | * Christoph Raisch <raisch@de.ibm.com> |
| 8 | * |
| 9 | * Copyright (c) 2005 IBM Corporation |
| 10 | * |
| 11 | * All rights reserved. |
| 12 | * |
| 13 | * This source code is distributed under a dual license of GPL v2.0 and OpenIB |
| 14 | * BSD. |
| 15 | * |
| 16 | * OpenIB BSD License |
| 17 | * |
| 18 | * Redistribution and use in source and binary forms, with or without |
| 19 | * modification, are permitted provided that the following conditions are met: |
| 20 | * |
| 21 | * Redistributions of source code must retain the above copyright notice, this |
| 22 | * list of conditions and the following disclaimer. |
| 23 | * |
| 24 | * Redistributions in binary form must reproduce the above copyright notice, |
| 25 | * this list of conditions and the following disclaimer in the documentation |
| 26 | * and/or other materials |
| 27 | * provided with the distribution. |
| 28 | * |
| 29 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| 30 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 31 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 32 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| 33 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 34 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 35 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| 36 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER |
| 37 | * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 38 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 39 | * POSSIBILITY OF SUCH DAMAGE. |
| 40 | */ |
| 41 | |
| 42 | #include <asm/current.h> |
| 43 | |
| 44 | #include "ehca_iverbs.h" |
| 45 | #include "ehca_mrmw.h" |
| 46 | #include "hcp_if.h" |
| 47 | #include "hipz_hw.h" |
| 48 | |
| 49 | static struct kmem_cache *mr_cache; |
| 50 | static struct kmem_cache *mw_cache; |
| 51 | |
| 52 | static struct ehca_mr *ehca_mr_new(void) |
| 53 | { |
| 54 | struct ehca_mr *me; |
| 55 | |
Robert P. J. Day | c376222 | 2007-02-10 01:45:03 -0800 | [diff] [blame^] | 56 | me = kmem_cache_zalloc(mr_cache, GFP_KERNEL); |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 57 | if (me) { |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 58 | spin_lock_init(&me->mrlock); |
| 59 | } else |
| 60 | ehca_gen_err("alloc failed"); |
| 61 | |
| 62 | return me; |
| 63 | } |
| 64 | |
| 65 | static void ehca_mr_delete(struct ehca_mr *me) |
| 66 | { |
| 67 | kmem_cache_free(mr_cache, me); |
| 68 | } |
| 69 | |
| 70 | static struct ehca_mw *ehca_mw_new(void) |
| 71 | { |
| 72 | struct ehca_mw *me; |
| 73 | |
Robert P. J. Day | c376222 | 2007-02-10 01:45:03 -0800 | [diff] [blame^] | 74 | me = kmem_cache_zalloc(mw_cache, GFP_KERNEL); |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 75 | if (me) { |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 76 | spin_lock_init(&me->mwlock); |
| 77 | } else |
| 78 | ehca_gen_err("alloc failed"); |
| 79 | |
| 80 | return me; |
| 81 | } |
| 82 | |
| 83 | static void ehca_mw_delete(struct ehca_mw *me) |
| 84 | { |
| 85 | kmem_cache_free(mw_cache, me); |
| 86 | } |
| 87 | |
| 88 | /*----------------------------------------------------------------------*/ |
| 89 | |
| 90 | struct ib_mr *ehca_get_dma_mr(struct ib_pd *pd, int mr_access_flags) |
| 91 | { |
| 92 | struct ib_mr *ib_mr; |
| 93 | int ret; |
| 94 | struct ehca_mr *e_maxmr; |
| 95 | struct ehca_pd *e_pd = container_of(pd, struct ehca_pd, ib_pd); |
| 96 | struct ehca_shca *shca = |
| 97 | container_of(pd->device, struct ehca_shca, ib_device); |
| 98 | |
| 99 | if (shca->maxmr) { |
| 100 | e_maxmr = ehca_mr_new(); |
| 101 | if (!e_maxmr) { |
| 102 | ehca_err(&shca->ib_device, "out of memory"); |
| 103 | ib_mr = ERR_PTR(-ENOMEM); |
| 104 | goto get_dma_mr_exit0; |
| 105 | } |
| 106 | |
| 107 | ret = ehca_reg_maxmr(shca, e_maxmr, (u64*)KERNELBASE, |
| 108 | mr_access_flags, e_pd, |
| 109 | &e_maxmr->ib.ib_mr.lkey, |
| 110 | &e_maxmr->ib.ib_mr.rkey); |
| 111 | if (ret) { |
| 112 | ib_mr = ERR_PTR(ret); |
| 113 | goto get_dma_mr_exit0; |
| 114 | } |
| 115 | ib_mr = &e_maxmr->ib.ib_mr; |
| 116 | } else { |
| 117 | ehca_err(&shca->ib_device, "no internal max-MR exist!"); |
| 118 | ib_mr = ERR_PTR(-EINVAL); |
| 119 | goto get_dma_mr_exit0; |
| 120 | } |
| 121 | |
| 122 | get_dma_mr_exit0: |
| 123 | if (IS_ERR(ib_mr)) |
| 124 | ehca_err(&shca->ib_device, "rc=%lx pd=%p mr_access_flags=%x ", |
| 125 | PTR_ERR(ib_mr), pd, mr_access_flags); |
| 126 | return ib_mr; |
| 127 | } /* end ehca_get_dma_mr() */ |
| 128 | |
| 129 | /*----------------------------------------------------------------------*/ |
| 130 | |
| 131 | struct ib_mr *ehca_reg_phys_mr(struct ib_pd *pd, |
| 132 | struct ib_phys_buf *phys_buf_array, |
| 133 | int num_phys_buf, |
| 134 | int mr_access_flags, |
| 135 | u64 *iova_start) |
| 136 | { |
| 137 | struct ib_mr *ib_mr; |
| 138 | int ret; |
| 139 | struct ehca_mr *e_mr; |
| 140 | struct ehca_shca *shca = |
| 141 | container_of(pd->device, struct ehca_shca, ib_device); |
| 142 | struct ehca_pd *e_pd = container_of(pd, struct ehca_pd, ib_pd); |
| 143 | |
| 144 | u64 size; |
| 145 | struct ehca_mr_pginfo pginfo={0,0,0,0,0,0,0,NULL,0,NULL,NULL,0,NULL,0}; |
| 146 | u32 num_pages_mr; |
| 147 | u32 num_pages_4k; /* 4k portion "pages" */ |
| 148 | |
| 149 | if ((num_phys_buf <= 0) || !phys_buf_array) { |
| 150 | ehca_err(pd->device, "bad input values: num_phys_buf=%x " |
| 151 | "phys_buf_array=%p", num_phys_buf, phys_buf_array); |
| 152 | ib_mr = ERR_PTR(-EINVAL); |
| 153 | goto reg_phys_mr_exit0; |
| 154 | } |
| 155 | if (((mr_access_flags & IB_ACCESS_REMOTE_WRITE) && |
| 156 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE)) || |
| 157 | ((mr_access_flags & IB_ACCESS_REMOTE_ATOMIC) && |
| 158 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE))) { |
| 159 | /* |
| 160 | * Remote Write Access requires Local Write Access |
| 161 | * Remote Atomic Access requires Local Write Access |
| 162 | */ |
| 163 | ehca_err(pd->device, "bad input values: mr_access_flags=%x", |
| 164 | mr_access_flags); |
| 165 | ib_mr = ERR_PTR(-EINVAL); |
| 166 | goto reg_phys_mr_exit0; |
| 167 | } |
| 168 | |
| 169 | /* check physical buffer list and calculate size */ |
| 170 | ret = ehca_mr_chk_buf_and_calc_size(phys_buf_array, num_phys_buf, |
| 171 | iova_start, &size); |
| 172 | if (ret) { |
| 173 | ib_mr = ERR_PTR(ret); |
| 174 | goto reg_phys_mr_exit0; |
| 175 | } |
| 176 | if ((size == 0) || |
| 177 | (((u64)iova_start + size) < (u64)iova_start)) { |
| 178 | ehca_err(pd->device, "bad input values: size=%lx iova_start=%p", |
| 179 | size, iova_start); |
| 180 | ib_mr = ERR_PTR(-EINVAL); |
| 181 | goto reg_phys_mr_exit0; |
| 182 | } |
| 183 | |
| 184 | e_mr = ehca_mr_new(); |
| 185 | if (!e_mr) { |
| 186 | ehca_err(pd->device, "out of memory"); |
| 187 | ib_mr = ERR_PTR(-ENOMEM); |
| 188 | goto reg_phys_mr_exit0; |
| 189 | } |
| 190 | |
| 191 | /* determine number of MR pages */ |
| 192 | num_pages_mr = ((((u64)iova_start % PAGE_SIZE) + size + |
| 193 | PAGE_SIZE - 1) / PAGE_SIZE); |
| 194 | num_pages_4k = ((((u64)iova_start % EHCA_PAGESIZE) + size + |
| 195 | EHCA_PAGESIZE - 1) / EHCA_PAGESIZE); |
| 196 | |
| 197 | /* register MR on HCA */ |
| 198 | if (ehca_mr_is_maxmr(size, iova_start)) { |
| 199 | e_mr->flags |= EHCA_MR_FLAG_MAXMR; |
| 200 | ret = ehca_reg_maxmr(shca, e_mr, iova_start, mr_access_flags, |
| 201 | e_pd, &e_mr->ib.ib_mr.lkey, |
| 202 | &e_mr->ib.ib_mr.rkey); |
| 203 | if (ret) { |
| 204 | ib_mr = ERR_PTR(ret); |
| 205 | goto reg_phys_mr_exit1; |
| 206 | } |
| 207 | } else { |
| 208 | pginfo.type = EHCA_MR_PGI_PHYS; |
| 209 | pginfo.num_pages = num_pages_mr; |
| 210 | pginfo.num_4k = num_pages_4k; |
| 211 | pginfo.num_phys_buf = num_phys_buf; |
| 212 | pginfo.phys_buf_array = phys_buf_array; |
| 213 | pginfo.next_4k = (((u64)iova_start & ~PAGE_MASK) / |
| 214 | EHCA_PAGESIZE); |
| 215 | |
| 216 | ret = ehca_reg_mr(shca, e_mr, iova_start, size, mr_access_flags, |
| 217 | e_pd, &pginfo, &e_mr->ib.ib_mr.lkey, |
| 218 | &e_mr->ib.ib_mr.rkey); |
| 219 | if (ret) { |
| 220 | ib_mr = ERR_PTR(ret); |
| 221 | goto reg_phys_mr_exit1; |
| 222 | } |
| 223 | } |
| 224 | |
| 225 | /* successful registration of all pages */ |
| 226 | return &e_mr->ib.ib_mr; |
| 227 | |
| 228 | reg_phys_mr_exit1: |
| 229 | ehca_mr_delete(e_mr); |
| 230 | reg_phys_mr_exit0: |
| 231 | if (IS_ERR(ib_mr)) |
| 232 | ehca_err(pd->device, "rc=%lx pd=%p phys_buf_array=%p " |
| 233 | "num_phys_buf=%x mr_access_flags=%x iova_start=%p", |
| 234 | PTR_ERR(ib_mr), pd, phys_buf_array, |
| 235 | num_phys_buf, mr_access_flags, iova_start); |
| 236 | return ib_mr; |
| 237 | } /* end ehca_reg_phys_mr() */ |
| 238 | |
| 239 | /*----------------------------------------------------------------------*/ |
| 240 | |
| 241 | struct ib_mr *ehca_reg_user_mr(struct ib_pd *pd, |
| 242 | struct ib_umem *region, |
| 243 | int mr_access_flags, |
| 244 | struct ib_udata *udata) |
| 245 | { |
| 246 | struct ib_mr *ib_mr; |
| 247 | struct ehca_mr *e_mr; |
| 248 | struct ehca_shca *shca = |
| 249 | container_of(pd->device, struct ehca_shca, ib_device); |
| 250 | struct ehca_pd *e_pd = container_of(pd, struct ehca_pd, ib_pd); |
| 251 | struct ehca_mr_pginfo pginfo={0,0,0,0,0,0,0,NULL,0,NULL,NULL,0,NULL,0}; |
| 252 | int ret; |
| 253 | u32 num_pages_mr; |
| 254 | u32 num_pages_4k; /* 4k portion "pages" */ |
| 255 | |
| 256 | if (!pd) { |
| 257 | ehca_gen_err("bad pd=%p", pd); |
| 258 | return ERR_PTR(-EFAULT); |
| 259 | } |
| 260 | if (!region) { |
| 261 | ehca_err(pd->device, "bad input values: region=%p", region); |
| 262 | ib_mr = ERR_PTR(-EINVAL); |
| 263 | goto reg_user_mr_exit0; |
| 264 | } |
| 265 | if (((mr_access_flags & IB_ACCESS_REMOTE_WRITE) && |
| 266 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE)) || |
| 267 | ((mr_access_flags & IB_ACCESS_REMOTE_ATOMIC) && |
| 268 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE))) { |
| 269 | /* |
| 270 | * Remote Write Access requires Local Write Access |
| 271 | * Remote Atomic Access requires Local Write Access |
| 272 | */ |
| 273 | ehca_err(pd->device, "bad input values: mr_access_flags=%x", |
| 274 | mr_access_flags); |
| 275 | ib_mr = ERR_PTR(-EINVAL); |
| 276 | goto reg_user_mr_exit0; |
| 277 | } |
| 278 | if (region->page_size != PAGE_SIZE) { |
| 279 | ehca_err(pd->device, "page size not supported, " |
| 280 | "region->page_size=%x", region->page_size); |
| 281 | ib_mr = ERR_PTR(-EINVAL); |
| 282 | goto reg_user_mr_exit0; |
| 283 | } |
| 284 | |
| 285 | if ((region->length == 0) || |
| 286 | ((region->virt_base + region->length) < region->virt_base)) { |
| 287 | ehca_err(pd->device, "bad input values: length=%lx " |
| 288 | "virt_base=%lx", region->length, region->virt_base); |
| 289 | ib_mr = ERR_PTR(-EINVAL); |
| 290 | goto reg_user_mr_exit0; |
| 291 | } |
| 292 | |
| 293 | e_mr = ehca_mr_new(); |
| 294 | if (!e_mr) { |
| 295 | ehca_err(pd->device, "out of memory"); |
| 296 | ib_mr = ERR_PTR(-ENOMEM); |
| 297 | goto reg_user_mr_exit0; |
| 298 | } |
| 299 | |
| 300 | /* determine number of MR pages */ |
| 301 | num_pages_mr = (((region->virt_base % PAGE_SIZE) + region->length + |
| 302 | PAGE_SIZE - 1) / PAGE_SIZE); |
| 303 | num_pages_4k = (((region->virt_base % EHCA_PAGESIZE) + region->length + |
| 304 | EHCA_PAGESIZE - 1) / EHCA_PAGESIZE); |
| 305 | |
| 306 | /* register MR on HCA */ |
| 307 | pginfo.type = EHCA_MR_PGI_USER; |
| 308 | pginfo.num_pages = num_pages_mr; |
| 309 | pginfo.num_4k = num_pages_4k; |
| 310 | pginfo.region = region; |
| 311 | pginfo.next_4k = region->offset / EHCA_PAGESIZE; |
| 312 | pginfo.next_chunk = list_prepare_entry(pginfo.next_chunk, |
| 313 | (®ion->chunk_list), |
| 314 | list); |
| 315 | |
| 316 | ret = ehca_reg_mr(shca, e_mr, (u64*)region->virt_base, |
| 317 | region->length, mr_access_flags, e_pd, &pginfo, |
| 318 | &e_mr->ib.ib_mr.lkey, &e_mr->ib.ib_mr.rkey); |
| 319 | if (ret) { |
| 320 | ib_mr = ERR_PTR(ret); |
| 321 | goto reg_user_mr_exit1; |
| 322 | } |
| 323 | |
| 324 | /* successful registration of all pages */ |
| 325 | return &e_mr->ib.ib_mr; |
| 326 | |
| 327 | reg_user_mr_exit1: |
| 328 | ehca_mr_delete(e_mr); |
| 329 | reg_user_mr_exit0: |
| 330 | if (IS_ERR(ib_mr)) |
| 331 | ehca_err(pd->device, "rc=%lx pd=%p region=%p mr_access_flags=%x" |
| 332 | " udata=%p", |
| 333 | PTR_ERR(ib_mr), pd, region, mr_access_flags, udata); |
| 334 | return ib_mr; |
| 335 | } /* end ehca_reg_user_mr() */ |
| 336 | |
| 337 | /*----------------------------------------------------------------------*/ |
| 338 | |
| 339 | int ehca_rereg_phys_mr(struct ib_mr *mr, |
| 340 | int mr_rereg_mask, |
| 341 | struct ib_pd *pd, |
| 342 | struct ib_phys_buf *phys_buf_array, |
| 343 | int num_phys_buf, |
| 344 | int mr_access_flags, |
| 345 | u64 *iova_start) |
| 346 | { |
| 347 | int ret; |
| 348 | |
| 349 | struct ehca_shca *shca = |
| 350 | container_of(mr->device, struct ehca_shca, ib_device); |
| 351 | struct ehca_mr *e_mr = container_of(mr, struct ehca_mr, ib.ib_mr); |
| 352 | struct ehca_pd *my_pd = container_of(mr->pd, struct ehca_pd, ib_pd); |
| 353 | u64 new_size; |
| 354 | u64 *new_start; |
| 355 | u32 new_acl; |
| 356 | struct ehca_pd *new_pd; |
| 357 | u32 tmp_lkey, tmp_rkey; |
| 358 | unsigned long sl_flags; |
| 359 | u32 num_pages_mr = 0; |
| 360 | u32 num_pages_4k = 0; /* 4k portion "pages" */ |
| 361 | struct ehca_mr_pginfo pginfo={0,0,0,0,0,0,0,NULL,0,NULL,NULL,0,NULL,0}; |
| 362 | u32 cur_pid = current->tgid; |
| 363 | |
| 364 | if (my_pd->ib_pd.uobject && my_pd->ib_pd.uobject->context && |
| 365 | (my_pd->ownpid != cur_pid)) { |
| 366 | ehca_err(mr->device, "Invalid caller pid=%x ownpid=%x", |
| 367 | cur_pid, my_pd->ownpid); |
| 368 | ret = -EINVAL; |
| 369 | goto rereg_phys_mr_exit0; |
| 370 | } |
| 371 | |
| 372 | if (!(mr_rereg_mask & IB_MR_REREG_TRANS)) { |
| 373 | /* TODO not supported, because PHYP rereg hCall needs pages */ |
| 374 | ehca_err(mr->device, "rereg without IB_MR_REREG_TRANS not " |
| 375 | "supported yet, mr_rereg_mask=%x", mr_rereg_mask); |
| 376 | ret = -EINVAL; |
| 377 | goto rereg_phys_mr_exit0; |
| 378 | } |
| 379 | |
| 380 | if (mr_rereg_mask & IB_MR_REREG_PD) { |
| 381 | if (!pd) { |
| 382 | ehca_err(mr->device, "rereg with bad pd, pd=%p " |
| 383 | "mr_rereg_mask=%x", pd, mr_rereg_mask); |
| 384 | ret = -EINVAL; |
| 385 | goto rereg_phys_mr_exit0; |
| 386 | } |
| 387 | } |
| 388 | |
| 389 | if ((mr_rereg_mask & |
| 390 | ~(IB_MR_REREG_TRANS | IB_MR_REREG_PD | IB_MR_REREG_ACCESS)) || |
| 391 | (mr_rereg_mask == 0)) { |
| 392 | ret = -EINVAL; |
| 393 | goto rereg_phys_mr_exit0; |
| 394 | } |
| 395 | |
| 396 | /* check other parameters */ |
| 397 | if (e_mr == shca->maxmr) { |
| 398 | /* should be impossible, however reject to be sure */ |
| 399 | ehca_err(mr->device, "rereg internal max-MR impossible, mr=%p " |
| 400 | "shca->maxmr=%p mr->lkey=%x", |
| 401 | mr, shca->maxmr, mr->lkey); |
| 402 | ret = -EINVAL; |
| 403 | goto rereg_phys_mr_exit0; |
| 404 | } |
| 405 | if (mr_rereg_mask & IB_MR_REREG_TRANS) { /* transl., i.e. addr/size */ |
| 406 | if (e_mr->flags & EHCA_MR_FLAG_FMR) { |
| 407 | ehca_err(mr->device, "not supported for FMR, mr=%p " |
| 408 | "flags=%x", mr, e_mr->flags); |
| 409 | ret = -EINVAL; |
| 410 | goto rereg_phys_mr_exit0; |
| 411 | } |
| 412 | if (!phys_buf_array || num_phys_buf <= 0) { |
| 413 | ehca_err(mr->device, "bad input values: mr_rereg_mask=%x" |
| 414 | " phys_buf_array=%p num_phys_buf=%x", |
| 415 | mr_rereg_mask, phys_buf_array, num_phys_buf); |
| 416 | ret = -EINVAL; |
| 417 | goto rereg_phys_mr_exit0; |
| 418 | } |
| 419 | } |
| 420 | if ((mr_rereg_mask & IB_MR_REREG_ACCESS) && /* change ACL */ |
| 421 | (((mr_access_flags & IB_ACCESS_REMOTE_WRITE) && |
| 422 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE)) || |
| 423 | ((mr_access_flags & IB_ACCESS_REMOTE_ATOMIC) && |
| 424 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE)))) { |
| 425 | /* |
| 426 | * Remote Write Access requires Local Write Access |
| 427 | * Remote Atomic Access requires Local Write Access |
| 428 | */ |
| 429 | ehca_err(mr->device, "bad input values: mr_rereg_mask=%x " |
| 430 | "mr_access_flags=%x", mr_rereg_mask, mr_access_flags); |
| 431 | ret = -EINVAL; |
| 432 | goto rereg_phys_mr_exit0; |
| 433 | } |
| 434 | |
| 435 | /* set requested values dependent on rereg request */ |
| 436 | spin_lock_irqsave(&e_mr->mrlock, sl_flags); |
| 437 | new_start = e_mr->start; /* new == old address */ |
| 438 | new_size = e_mr->size; /* new == old length */ |
| 439 | new_acl = e_mr->acl; /* new == old access control */ |
| 440 | new_pd = container_of(mr->pd,struct ehca_pd,ib_pd); /*new == old PD*/ |
| 441 | |
| 442 | if (mr_rereg_mask & IB_MR_REREG_TRANS) { |
| 443 | new_start = iova_start; /* change address */ |
| 444 | /* check physical buffer list and calculate size */ |
| 445 | ret = ehca_mr_chk_buf_and_calc_size(phys_buf_array, |
| 446 | num_phys_buf, iova_start, |
| 447 | &new_size); |
| 448 | if (ret) |
| 449 | goto rereg_phys_mr_exit1; |
| 450 | if ((new_size == 0) || |
| 451 | (((u64)iova_start + new_size) < (u64)iova_start)) { |
| 452 | ehca_err(mr->device, "bad input values: new_size=%lx " |
| 453 | "iova_start=%p", new_size, iova_start); |
| 454 | ret = -EINVAL; |
| 455 | goto rereg_phys_mr_exit1; |
| 456 | } |
| 457 | num_pages_mr = ((((u64)new_start % PAGE_SIZE) + new_size + |
| 458 | PAGE_SIZE - 1) / PAGE_SIZE); |
| 459 | num_pages_4k = ((((u64)new_start % EHCA_PAGESIZE) + new_size + |
| 460 | EHCA_PAGESIZE - 1) / EHCA_PAGESIZE); |
| 461 | pginfo.type = EHCA_MR_PGI_PHYS; |
| 462 | pginfo.num_pages = num_pages_mr; |
| 463 | pginfo.num_4k = num_pages_4k; |
| 464 | pginfo.num_phys_buf = num_phys_buf; |
| 465 | pginfo.phys_buf_array = phys_buf_array; |
| 466 | pginfo.next_4k = (((u64)iova_start & ~PAGE_MASK) / |
| 467 | EHCA_PAGESIZE); |
| 468 | } |
| 469 | if (mr_rereg_mask & IB_MR_REREG_ACCESS) |
| 470 | new_acl = mr_access_flags; |
| 471 | if (mr_rereg_mask & IB_MR_REREG_PD) |
| 472 | new_pd = container_of(pd, struct ehca_pd, ib_pd); |
| 473 | |
| 474 | ret = ehca_rereg_mr(shca, e_mr, new_start, new_size, new_acl, |
| 475 | new_pd, &pginfo, &tmp_lkey, &tmp_rkey); |
| 476 | if (ret) |
| 477 | goto rereg_phys_mr_exit1; |
| 478 | |
| 479 | /* successful reregistration */ |
| 480 | if (mr_rereg_mask & IB_MR_REREG_PD) |
| 481 | mr->pd = pd; |
| 482 | mr->lkey = tmp_lkey; |
| 483 | mr->rkey = tmp_rkey; |
| 484 | |
| 485 | rereg_phys_mr_exit1: |
| 486 | spin_unlock_irqrestore(&e_mr->mrlock, sl_flags); |
| 487 | rereg_phys_mr_exit0: |
| 488 | if (ret) |
| 489 | ehca_err(mr->device, "ret=%x mr=%p mr_rereg_mask=%x pd=%p " |
| 490 | "phys_buf_array=%p num_phys_buf=%x mr_access_flags=%x " |
| 491 | "iova_start=%p", |
| 492 | ret, mr, mr_rereg_mask, pd, phys_buf_array, |
| 493 | num_phys_buf, mr_access_flags, iova_start); |
| 494 | return ret; |
| 495 | } /* end ehca_rereg_phys_mr() */ |
| 496 | |
| 497 | /*----------------------------------------------------------------------*/ |
| 498 | |
| 499 | int ehca_query_mr(struct ib_mr *mr, struct ib_mr_attr *mr_attr) |
| 500 | { |
| 501 | int ret = 0; |
| 502 | u64 h_ret; |
| 503 | struct ehca_shca *shca = |
| 504 | container_of(mr->device, struct ehca_shca, ib_device); |
| 505 | struct ehca_mr *e_mr = container_of(mr, struct ehca_mr, ib.ib_mr); |
| 506 | struct ehca_pd *my_pd = container_of(mr->pd, struct ehca_pd, ib_pd); |
| 507 | u32 cur_pid = current->tgid; |
| 508 | unsigned long sl_flags; |
| 509 | struct ehca_mr_hipzout_parms hipzout = {{0},0,0,0,0,0}; |
| 510 | |
| 511 | if (my_pd->ib_pd.uobject && my_pd->ib_pd.uobject->context && |
| 512 | (my_pd->ownpid != cur_pid)) { |
| 513 | ehca_err(mr->device, "Invalid caller pid=%x ownpid=%x", |
| 514 | cur_pid, my_pd->ownpid); |
| 515 | ret = -EINVAL; |
| 516 | goto query_mr_exit0; |
| 517 | } |
| 518 | |
| 519 | if ((e_mr->flags & EHCA_MR_FLAG_FMR)) { |
| 520 | ehca_err(mr->device, "not supported for FMR, mr=%p e_mr=%p " |
| 521 | "e_mr->flags=%x", mr, e_mr, e_mr->flags); |
| 522 | ret = -EINVAL; |
| 523 | goto query_mr_exit0; |
| 524 | } |
| 525 | |
| 526 | memset(mr_attr, 0, sizeof(struct ib_mr_attr)); |
| 527 | spin_lock_irqsave(&e_mr->mrlock, sl_flags); |
| 528 | |
| 529 | h_ret = hipz_h_query_mr(shca->ipz_hca_handle, e_mr, &hipzout); |
| 530 | if (h_ret != H_SUCCESS) { |
| 531 | ehca_err(mr->device, "hipz_mr_query failed, h_ret=%lx mr=%p " |
| 532 | "hca_hndl=%lx mr_hndl=%lx lkey=%x", |
| 533 | h_ret, mr, shca->ipz_hca_handle.handle, |
| 534 | e_mr->ipz_mr_handle.handle, mr->lkey); |
| 535 | ret = ehca_mrmw_map_hrc_query_mr(h_ret); |
| 536 | goto query_mr_exit1; |
| 537 | } |
| 538 | mr_attr->pd = mr->pd; |
| 539 | mr_attr->device_virt_addr = hipzout.vaddr; |
| 540 | mr_attr->size = hipzout.len; |
| 541 | mr_attr->lkey = hipzout.lkey; |
| 542 | mr_attr->rkey = hipzout.rkey; |
| 543 | ehca_mrmw_reverse_map_acl(&hipzout.acl, &mr_attr->mr_access_flags); |
| 544 | |
| 545 | query_mr_exit1: |
| 546 | spin_unlock_irqrestore(&e_mr->mrlock, sl_flags); |
| 547 | query_mr_exit0: |
| 548 | if (ret) |
| 549 | ehca_err(mr->device, "ret=%x mr=%p mr_attr=%p", |
| 550 | ret, mr, mr_attr); |
| 551 | return ret; |
| 552 | } /* end ehca_query_mr() */ |
| 553 | |
| 554 | /*----------------------------------------------------------------------*/ |
| 555 | |
| 556 | int ehca_dereg_mr(struct ib_mr *mr) |
| 557 | { |
| 558 | int ret = 0; |
| 559 | u64 h_ret; |
| 560 | struct ehca_shca *shca = |
| 561 | container_of(mr->device, struct ehca_shca, ib_device); |
| 562 | struct ehca_mr *e_mr = container_of(mr, struct ehca_mr, ib.ib_mr); |
| 563 | struct ehca_pd *my_pd = container_of(mr->pd, struct ehca_pd, ib_pd); |
| 564 | u32 cur_pid = current->tgid; |
| 565 | |
| 566 | if (my_pd->ib_pd.uobject && my_pd->ib_pd.uobject->context && |
| 567 | (my_pd->ownpid != cur_pid)) { |
| 568 | ehca_err(mr->device, "Invalid caller pid=%x ownpid=%x", |
| 569 | cur_pid, my_pd->ownpid); |
| 570 | ret = -EINVAL; |
| 571 | goto dereg_mr_exit0; |
| 572 | } |
| 573 | |
| 574 | if ((e_mr->flags & EHCA_MR_FLAG_FMR)) { |
| 575 | ehca_err(mr->device, "not supported for FMR, mr=%p e_mr=%p " |
| 576 | "e_mr->flags=%x", mr, e_mr, e_mr->flags); |
| 577 | ret = -EINVAL; |
| 578 | goto dereg_mr_exit0; |
| 579 | } else if (e_mr == shca->maxmr) { |
| 580 | /* should be impossible, however reject to be sure */ |
| 581 | ehca_err(mr->device, "dereg internal max-MR impossible, mr=%p " |
| 582 | "shca->maxmr=%p mr->lkey=%x", |
| 583 | mr, shca->maxmr, mr->lkey); |
| 584 | ret = -EINVAL; |
| 585 | goto dereg_mr_exit0; |
| 586 | } |
| 587 | |
| 588 | /* TODO: BUSY: MR still has bound window(s) */ |
| 589 | h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr); |
| 590 | if (h_ret != H_SUCCESS) { |
| 591 | ehca_err(mr->device, "hipz_free_mr failed, h_ret=%lx shca=%p " |
| 592 | "e_mr=%p hca_hndl=%lx mr_hndl=%lx mr->lkey=%x", |
| 593 | h_ret, shca, e_mr, shca->ipz_hca_handle.handle, |
| 594 | e_mr->ipz_mr_handle.handle, mr->lkey); |
| 595 | ret = ehca_mrmw_map_hrc_free_mr(h_ret); |
| 596 | goto dereg_mr_exit0; |
| 597 | } |
| 598 | |
| 599 | /* successful deregistration */ |
| 600 | ehca_mr_delete(e_mr); |
| 601 | |
| 602 | dereg_mr_exit0: |
| 603 | if (ret) |
| 604 | ehca_err(mr->device, "ret=%x mr=%p", ret, mr); |
| 605 | return ret; |
| 606 | } /* end ehca_dereg_mr() */ |
| 607 | |
| 608 | /*----------------------------------------------------------------------*/ |
| 609 | |
| 610 | struct ib_mw *ehca_alloc_mw(struct ib_pd *pd) |
| 611 | { |
| 612 | struct ib_mw *ib_mw; |
| 613 | u64 h_ret; |
| 614 | struct ehca_mw *e_mw; |
| 615 | struct ehca_pd *e_pd = container_of(pd, struct ehca_pd, ib_pd); |
| 616 | struct ehca_shca *shca = |
| 617 | container_of(pd->device, struct ehca_shca, ib_device); |
| 618 | struct ehca_mw_hipzout_parms hipzout = {{0},0}; |
| 619 | |
| 620 | e_mw = ehca_mw_new(); |
| 621 | if (!e_mw) { |
| 622 | ib_mw = ERR_PTR(-ENOMEM); |
| 623 | goto alloc_mw_exit0; |
| 624 | } |
| 625 | |
| 626 | h_ret = hipz_h_alloc_resource_mw(shca->ipz_hca_handle, e_mw, |
| 627 | e_pd->fw_pd, &hipzout); |
| 628 | if (h_ret != H_SUCCESS) { |
| 629 | ehca_err(pd->device, "hipz_mw_allocate failed, h_ret=%lx " |
| 630 | "shca=%p hca_hndl=%lx mw=%p", |
| 631 | h_ret, shca, shca->ipz_hca_handle.handle, e_mw); |
| 632 | ib_mw = ERR_PTR(ehca_mrmw_map_hrc_alloc(h_ret)); |
| 633 | goto alloc_mw_exit1; |
| 634 | } |
| 635 | /* successful MW allocation */ |
| 636 | e_mw->ipz_mw_handle = hipzout.handle; |
| 637 | e_mw->ib_mw.rkey = hipzout.rkey; |
| 638 | return &e_mw->ib_mw; |
| 639 | |
| 640 | alloc_mw_exit1: |
| 641 | ehca_mw_delete(e_mw); |
| 642 | alloc_mw_exit0: |
| 643 | if (IS_ERR(ib_mw)) |
| 644 | ehca_err(pd->device, "rc=%lx pd=%p", PTR_ERR(ib_mw), pd); |
| 645 | return ib_mw; |
| 646 | } /* end ehca_alloc_mw() */ |
| 647 | |
| 648 | /*----------------------------------------------------------------------*/ |
| 649 | |
| 650 | int ehca_bind_mw(struct ib_qp *qp, |
| 651 | struct ib_mw *mw, |
| 652 | struct ib_mw_bind *mw_bind) |
| 653 | { |
| 654 | /* TODO: not supported up to now */ |
| 655 | ehca_gen_err("bind MW currently not supported by HCAD"); |
| 656 | |
| 657 | return -EPERM; |
| 658 | } /* end ehca_bind_mw() */ |
| 659 | |
| 660 | /*----------------------------------------------------------------------*/ |
| 661 | |
| 662 | int ehca_dealloc_mw(struct ib_mw *mw) |
| 663 | { |
| 664 | u64 h_ret; |
| 665 | struct ehca_shca *shca = |
| 666 | container_of(mw->device, struct ehca_shca, ib_device); |
| 667 | struct ehca_mw *e_mw = container_of(mw, struct ehca_mw, ib_mw); |
| 668 | |
| 669 | h_ret = hipz_h_free_resource_mw(shca->ipz_hca_handle, e_mw); |
| 670 | if (h_ret != H_SUCCESS) { |
| 671 | ehca_err(mw->device, "hipz_free_mw failed, h_ret=%lx shca=%p " |
| 672 | "mw=%p rkey=%x hca_hndl=%lx mw_hndl=%lx", |
| 673 | h_ret, shca, mw, mw->rkey, shca->ipz_hca_handle.handle, |
| 674 | e_mw->ipz_mw_handle.handle); |
| 675 | return ehca_mrmw_map_hrc_free_mw(h_ret); |
| 676 | } |
| 677 | /* successful deallocation */ |
| 678 | ehca_mw_delete(e_mw); |
| 679 | return 0; |
| 680 | } /* end ehca_dealloc_mw() */ |
| 681 | |
| 682 | /*----------------------------------------------------------------------*/ |
| 683 | |
| 684 | struct ib_fmr *ehca_alloc_fmr(struct ib_pd *pd, |
| 685 | int mr_access_flags, |
| 686 | struct ib_fmr_attr *fmr_attr) |
| 687 | { |
| 688 | struct ib_fmr *ib_fmr; |
| 689 | struct ehca_shca *shca = |
| 690 | container_of(pd->device, struct ehca_shca, ib_device); |
| 691 | struct ehca_pd *e_pd = container_of(pd, struct ehca_pd, ib_pd); |
| 692 | struct ehca_mr *e_fmr; |
| 693 | int ret; |
| 694 | u32 tmp_lkey, tmp_rkey; |
| 695 | struct ehca_mr_pginfo pginfo={0,0,0,0,0,0,0,NULL,0,NULL,NULL,0,NULL,0}; |
| 696 | |
| 697 | /* check other parameters */ |
| 698 | if (((mr_access_flags & IB_ACCESS_REMOTE_WRITE) && |
| 699 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE)) || |
| 700 | ((mr_access_flags & IB_ACCESS_REMOTE_ATOMIC) && |
| 701 | !(mr_access_flags & IB_ACCESS_LOCAL_WRITE))) { |
| 702 | /* |
| 703 | * Remote Write Access requires Local Write Access |
| 704 | * Remote Atomic Access requires Local Write Access |
| 705 | */ |
| 706 | ehca_err(pd->device, "bad input values: mr_access_flags=%x", |
| 707 | mr_access_flags); |
| 708 | ib_fmr = ERR_PTR(-EINVAL); |
| 709 | goto alloc_fmr_exit0; |
| 710 | } |
| 711 | if (mr_access_flags & IB_ACCESS_MW_BIND) { |
| 712 | ehca_err(pd->device, "bad input values: mr_access_flags=%x", |
| 713 | mr_access_flags); |
| 714 | ib_fmr = ERR_PTR(-EINVAL); |
| 715 | goto alloc_fmr_exit0; |
| 716 | } |
| 717 | if ((fmr_attr->max_pages == 0) || (fmr_attr->max_maps == 0)) { |
| 718 | ehca_err(pd->device, "bad input values: fmr_attr->max_pages=%x " |
| 719 | "fmr_attr->max_maps=%x fmr_attr->page_shift=%x", |
| 720 | fmr_attr->max_pages, fmr_attr->max_maps, |
| 721 | fmr_attr->page_shift); |
| 722 | ib_fmr = ERR_PTR(-EINVAL); |
| 723 | goto alloc_fmr_exit0; |
| 724 | } |
| 725 | if (((1 << fmr_attr->page_shift) != EHCA_PAGESIZE) && |
| 726 | ((1 << fmr_attr->page_shift) != PAGE_SIZE)) { |
| 727 | ehca_err(pd->device, "unsupported fmr_attr->page_shift=%x", |
| 728 | fmr_attr->page_shift); |
| 729 | ib_fmr = ERR_PTR(-EINVAL); |
| 730 | goto alloc_fmr_exit0; |
| 731 | } |
| 732 | |
| 733 | e_fmr = ehca_mr_new(); |
| 734 | if (!e_fmr) { |
| 735 | ib_fmr = ERR_PTR(-ENOMEM); |
| 736 | goto alloc_fmr_exit0; |
| 737 | } |
| 738 | e_fmr->flags |= EHCA_MR_FLAG_FMR; |
| 739 | |
| 740 | /* register MR on HCA */ |
| 741 | ret = ehca_reg_mr(shca, e_fmr, NULL, |
| 742 | fmr_attr->max_pages * (1 << fmr_attr->page_shift), |
| 743 | mr_access_flags, e_pd, &pginfo, |
| 744 | &tmp_lkey, &tmp_rkey); |
| 745 | if (ret) { |
| 746 | ib_fmr = ERR_PTR(ret); |
| 747 | goto alloc_fmr_exit1; |
| 748 | } |
| 749 | |
| 750 | /* successful */ |
| 751 | e_fmr->fmr_page_size = 1 << fmr_attr->page_shift; |
| 752 | e_fmr->fmr_max_pages = fmr_attr->max_pages; |
| 753 | e_fmr->fmr_max_maps = fmr_attr->max_maps; |
| 754 | e_fmr->fmr_map_cnt = 0; |
| 755 | return &e_fmr->ib.ib_fmr; |
| 756 | |
| 757 | alloc_fmr_exit1: |
| 758 | ehca_mr_delete(e_fmr); |
| 759 | alloc_fmr_exit0: |
| 760 | if (IS_ERR(ib_fmr)) |
| 761 | ehca_err(pd->device, "rc=%lx pd=%p mr_access_flags=%x " |
| 762 | "fmr_attr=%p", PTR_ERR(ib_fmr), pd, |
| 763 | mr_access_flags, fmr_attr); |
| 764 | return ib_fmr; |
| 765 | } /* end ehca_alloc_fmr() */ |
| 766 | |
| 767 | /*----------------------------------------------------------------------*/ |
| 768 | |
| 769 | int ehca_map_phys_fmr(struct ib_fmr *fmr, |
| 770 | u64 *page_list, |
| 771 | int list_len, |
| 772 | u64 iova) |
| 773 | { |
| 774 | int ret; |
| 775 | struct ehca_shca *shca = |
| 776 | container_of(fmr->device, struct ehca_shca, ib_device); |
| 777 | struct ehca_mr *e_fmr = container_of(fmr, struct ehca_mr, ib.ib_fmr); |
| 778 | struct ehca_pd *e_pd = container_of(fmr->pd, struct ehca_pd, ib_pd); |
| 779 | struct ehca_mr_pginfo pginfo={0,0,0,0,0,0,0,NULL,0,NULL,NULL,0,NULL,0}; |
| 780 | u32 tmp_lkey, tmp_rkey; |
| 781 | |
| 782 | if (!(e_fmr->flags & EHCA_MR_FLAG_FMR)) { |
| 783 | ehca_err(fmr->device, "not a FMR, e_fmr=%p e_fmr->flags=%x", |
| 784 | e_fmr, e_fmr->flags); |
| 785 | ret = -EINVAL; |
| 786 | goto map_phys_fmr_exit0; |
| 787 | } |
| 788 | ret = ehca_fmr_check_page_list(e_fmr, page_list, list_len); |
| 789 | if (ret) |
| 790 | goto map_phys_fmr_exit0; |
| 791 | if (iova % e_fmr->fmr_page_size) { |
| 792 | /* only whole-numbered pages */ |
| 793 | ehca_err(fmr->device, "bad iova, iova=%lx fmr_page_size=%x", |
| 794 | iova, e_fmr->fmr_page_size); |
| 795 | ret = -EINVAL; |
| 796 | goto map_phys_fmr_exit0; |
| 797 | } |
| 798 | if (e_fmr->fmr_map_cnt >= e_fmr->fmr_max_maps) { |
| 799 | /* HCAD does not limit the maps, however trace this anyway */ |
| 800 | ehca_info(fmr->device, "map limit exceeded, fmr=%p " |
| 801 | "e_fmr->fmr_map_cnt=%x e_fmr->fmr_max_maps=%x", |
| 802 | fmr, e_fmr->fmr_map_cnt, e_fmr->fmr_max_maps); |
| 803 | } |
| 804 | |
| 805 | pginfo.type = EHCA_MR_PGI_FMR; |
| 806 | pginfo.num_pages = list_len; |
| 807 | pginfo.num_4k = list_len * (e_fmr->fmr_page_size / EHCA_PAGESIZE); |
| 808 | pginfo.page_list = page_list; |
| 809 | pginfo.next_4k = ((iova & (e_fmr->fmr_page_size-1)) / |
| 810 | EHCA_PAGESIZE); |
| 811 | |
| 812 | ret = ehca_rereg_mr(shca, e_fmr, (u64*)iova, |
| 813 | list_len * e_fmr->fmr_page_size, |
| 814 | e_fmr->acl, e_pd, &pginfo, &tmp_lkey, &tmp_rkey); |
| 815 | if (ret) |
| 816 | goto map_phys_fmr_exit0; |
| 817 | |
| 818 | /* successful reregistration */ |
| 819 | e_fmr->fmr_map_cnt++; |
| 820 | e_fmr->ib.ib_fmr.lkey = tmp_lkey; |
| 821 | e_fmr->ib.ib_fmr.rkey = tmp_rkey; |
| 822 | return 0; |
| 823 | |
| 824 | map_phys_fmr_exit0: |
| 825 | if (ret) |
| 826 | ehca_err(fmr->device, "ret=%x fmr=%p page_list=%p list_len=%x " |
| 827 | "iova=%lx", |
| 828 | ret, fmr, page_list, list_len, iova); |
| 829 | return ret; |
| 830 | } /* end ehca_map_phys_fmr() */ |
| 831 | |
| 832 | /*----------------------------------------------------------------------*/ |
| 833 | |
| 834 | int ehca_unmap_fmr(struct list_head *fmr_list) |
| 835 | { |
| 836 | int ret = 0; |
| 837 | struct ib_fmr *ib_fmr; |
| 838 | struct ehca_shca *shca = NULL; |
| 839 | struct ehca_shca *prev_shca; |
| 840 | struct ehca_mr *e_fmr; |
| 841 | u32 num_fmr = 0; |
| 842 | u32 unmap_fmr_cnt = 0; |
| 843 | |
| 844 | /* check all FMR belong to same SHCA, and check internal flag */ |
| 845 | list_for_each_entry(ib_fmr, fmr_list, list) { |
| 846 | prev_shca = shca; |
| 847 | if (!ib_fmr) { |
| 848 | ehca_gen_err("bad fmr=%p in list", ib_fmr); |
| 849 | ret = -EINVAL; |
| 850 | goto unmap_fmr_exit0; |
| 851 | } |
| 852 | shca = container_of(ib_fmr->device, struct ehca_shca, |
| 853 | ib_device); |
| 854 | e_fmr = container_of(ib_fmr, struct ehca_mr, ib.ib_fmr); |
| 855 | if ((shca != prev_shca) && prev_shca) { |
| 856 | ehca_err(&shca->ib_device, "SHCA mismatch, shca=%p " |
| 857 | "prev_shca=%p e_fmr=%p", |
| 858 | shca, prev_shca, e_fmr); |
| 859 | ret = -EINVAL; |
| 860 | goto unmap_fmr_exit0; |
| 861 | } |
| 862 | if (!(e_fmr->flags & EHCA_MR_FLAG_FMR)) { |
| 863 | ehca_err(&shca->ib_device, "not a FMR, e_fmr=%p " |
| 864 | "e_fmr->flags=%x", e_fmr, e_fmr->flags); |
| 865 | ret = -EINVAL; |
| 866 | goto unmap_fmr_exit0; |
| 867 | } |
| 868 | num_fmr++; |
| 869 | } |
| 870 | |
| 871 | /* loop over all FMRs to unmap */ |
| 872 | list_for_each_entry(ib_fmr, fmr_list, list) { |
| 873 | unmap_fmr_cnt++; |
| 874 | e_fmr = container_of(ib_fmr, struct ehca_mr, ib.ib_fmr); |
| 875 | shca = container_of(ib_fmr->device, struct ehca_shca, |
| 876 | ib_device); |
| 877 | ret = ehca_unmap_one_fmr(shca, e_fmr); |
| 878 | if (ret) { |
| 879 | /* unmap failed, stop unmapping of rest of FMRs */ |
| 880 | ehca_err(&shca->ib_device, "unmap of one FMR failed, " |
| 881 | "stop rest, e_fmr=%p num_fmr=%x " |
| 882 | "unmap_fmr_cnt=%x lkey=%x", e_fmr, num_fmr, |
| 883 | unmap_fmr_cnt, e_fmr->ib.ib_fmr.lkey); |
| 884 | goto unmap_fmr_exit0; |
| 885 | } |
| 886 | } |
| 887 | |
| 888 | unmap_fmr_exit0: |
| 889 | if (ret) |
| 890 | ehca_gen_err("ret=%x fmr_list=%p num_fmr=%x unmap_fmr_cnt=%x", |
| 891 | ret, fmr_list, num_fmr, unmap_fmr_cnt); |
| 892 | return ret; |
| 893 | } /* end ehca_unmap_fmr() */ |
| 894 | |
| 895 | /*----------------------------------------------------------------------*/ |
| 896 | |
| 897 | int ehca_dealloc_fmr(struct ib_fmr *fmr) |
| 898 | { |
| 899 | int ret; |
| 900 | u64 h_ret; |
| 901 | struct ehca_shca *shca = |
| 902 | container_of(fmr->device, struct ehca_shca, ib_device); |
| 903 | struct ehca_mr *e_fmr = container_of(fmr, struct ehca_mr, ib.ib_fmr); |
| 904 | |
| 905 | if (!(e_fmr->flags & EHCA_MR_FLAG_FMR)) { |
| 906 | ehca_err(fmr->device, "not a FMR, e_fmr=%p e_fmr->flags=%x", |
| 907 | e_fmr, e_fmr->flags); |
| 908 | ret = -EINVAL; |
| 909 | goto free_fmr_exit0; |
| 910 | } |
| 911 | |
| 912 | h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_fmr); |
| 913 | if (h_ret != H_SUCCESS) { |
| 914 | ehca_err(fmr->device, "hipz_free_mr failed, h_ret=%lx e_fmr=%p " |
| 915 | "hca_hndl=%lx fmr_hndl=%lx fmr->lkey=%x", |
| 916 | h_ret, e_fmr, shca->ipz_hca_handle.handle, |
| 917 | e_fmr->ipz_mr_handle.handle, fmr->lkey); |
| 918 | ret = ehca_mrmw_map_hrc_free_mr(h_ret); |
| 919 | goto free_fmr_exit0; |
| 920 | } |
| 921 | /* successful deregistration */ |
| 922 | ehca_mr_delete(e_fmr); |
| 923 | return 0; |
| 924 | |
| 925 | free_fmr_exit0: |
| 926 | if (ret) |
| 927 | ehca_err(&shca->ib_device, "ret=%x fmr=%p", ret, fmr); |
| 928 | return ret; |
| 929 | } /* end ehca_dealloc_fmr() */ |
| 930 | |
| 931 | /*----------------------------------------------------------------------*/ |
| 932 | |
| 933 | int ehca_reg_mr(struct ehca_shca *shca, |
| 934 | struct ehca_mr *e_mr, |
| 935 | u64 *iova_start, |
| 936 | u64 size, |
| 937 | int acl, |
| 938 | struct ehca_pd *e_pd, |
| 939 | struct ehca_mr_pginfo *pginfo, |
| 940 | u32 *lkey, /*OUT*/ |
| 941 | u32 *rkey) /*OUT*/ |
| 942 | { |
| 943 | int ret; |
| 944 | u64 h_ret; |
| 945 | u32 hipz_acl; |
| 946 | struct ehca_mr_hipzout_parms hipzout = {{0},0,0,0,0,0}; |
| 947 | |
| 948 | ehca_mrmw_map_acl(acl, &hipz_acl); |
| 949 | ehca_mrmw_set_pgsize_hipz_acl(&hipz_acl); |
| 950 | if (ehca_use_hp_mr == 1) |
| 951 | hipz_acl |= 0x00000001; |
| 952 | |
| 953 | h_ret = hipz_h_alloc_resource_mr(shca->ipz_hca_handle, e_mr, |
| 954 | (u64)iova_start, size, hipz_acl, |
| 955 | e_pd->fw_pd, &hipzout); |
| 956 | if (h_ret != H_SUCCESS) { |
| 957 | ehca_err(&shca->ib_device, "hipz_alloc_mr failed, h_ret=%lx " |
| 958 | "hca_hndl=%lx", h_ret, shca->ipz_hca_handle.handle); |
| 959 | ret = ehca_mrmw_map_hrc_alloc(h_ret); |
| 960 | goto ehca_reg_mr_exit0; |
| 961 | } |
| 962 | |
| 963 | e_mr->ipz_mr_handle = hipzout.handle; |
| 964 | |
| 965 | ret = ehca_reg_mr_rpages(shca, e_mr, pginfo); |
| 966 | if (ret) |
| 967 | goto ehca_reg_mr_exit1; |
| 968 | |
| 969 | /* successful registration */ |
| 970 | e_mr->num_pages = pginfo->num_pages; |
| 971 | e_mr->num_4k = pginfo->num_4k; |
| 972 | e_mr->start = iova_start; |
| 973 | e_mr->size = size; |
| 974 | e_mr->acl = acl; |
| 975 | *lkey = hipzout.lkey; |
| 976 | *rkey = hipzout.rkey; |
| 977 | return 0; |
| 978 | |
| 979 | ehca_reg_mr_exit1: |
| 980 | h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr); |
| 981 | if (h_ret != H_SUCCESS) { |
| 982 | ehca_err(&shca->ib_device, "h_ret=%lx shca=%p e_mr=%p " |
| 983 | "iova_start=%p size=%lx acl=%x e_pd=%p lkey=%x " |
| 984 | "pginfo=%p num_pages=%lx num_4k=%lx ret=%x", |
| 985 | h_ret, shca, e_mr, iova_start, size, acl, e_pd, |
| 986 | hipzout.lkey, pginfo, pginfo->num_pages, |
| 987 | pginfo->num_4k, ret); |
| 988 | ehca_err(&shca->ib_device, "internal error in ehca_reg_mr, " |
| 989 | "not recoverable"); |
| 990 | } |
| 991 | ehca_reg_mr_exit0: |
| 992 | if (ret) |
| 993 | ehca_err(&shca->ib_device, "ret=%x shca=%p e_mr=%p " |
| 994 | "iova_start=%p size=%lx acl=%x e_pd=%p pginfo=%p " |
| 995 | "num_pages=%lx num_4k=%lx", |
| 996 | ret, shca, e_mr, iova_start, size, acl, e_pd, pginfo, |
| 997 | pginfo->num_pages, pginfo->num_4k); |
| 998 | return ret; |
| 999 | } /* end ehca_reg_mr() */ |
| 1000 | |
| 1001 | /*----------------------------------------------------------------------*/ |
| 1002 | |
| 1003 | int ehca_reg_mr_rpages(struct ehca_shca *shca, |
| 1004 | struct ehca_mr *e_mr, |
| 1005 | struct ehca_mr_pginfo *pginfo) |
| 1006 | { |
| 1007 | int ret = 0; |
| 1008 | u64 h_ret; |
| 1009 | u32 rnum; |
| 1010 | u64 rpage; |
| 1011 | u32 i; |
| 1012 | u64 *kpage; |
| 1013 | |
Hoang-Nam Nguyen | f2d9136 | 2007-01-09 18:04:14 +0100 | [diff] [blame] | 1014 | kpage = ehca_alloc_fw_ctrlblock(GFP_KERNEL); |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 1015 | if (!kpage) { |
| 1016 | ehca_err(&shca->ib_device, "kpage alloc failed"); |
| 1017 | ret = -ENOMEM; |
| 1018 | goto ehca_reg_mr_rpages_exit0; |
| 1019 | } |
| 1020 | |
| 1021 | /* max 512 pages per shot */ |
| 1022 | for (i = 0; i < ((pginfo->num_4k + 512 - 1) / 512); i++) { |
| 1023 | |
| 1024 | if (i == ((pginfo->num_4k + 512 - 1) / 512) - 1) { |
| 1025 | rnum = pginfo->num_4k % 512; /* last shot */ |
| 1026 | if (rnum == 0) |
| 1027 | rnum = 512; /* last shot is full */ |
| 1028 | } else |
| 1029 | rnum = 512; |
| 1030 | |
| 1031 | if (rnum > 1) { |
| 1032 | ret = ehca_set_pagebuf(e_mr, pginfo, rnum, kpage); |
| 1033 | if (ret) { |
| 1034 | ehca_err(&shca->ib_device, "ehca_set_pagebuf " |
| 1035 | "bad rc, ret=%x rnum=%x kpage=%p", |
| 1036 | ret, rnum, kpage); |
| 1037 | ret = -EFAULT; |
| 1038 | goto ehca_reg_mr_rpages_exit1; |
| 1039 | } |
| 1040 | rpage = virt_to_abs(kpage); |
| 1041 | if (!rpage) { |
| 1042 | ehca_err(&shca->ib_device, "kpage=%p i=%x", |
| 1043 | kpage, i); |
| 1044 | ret = -EFAULT; |
| 1045 | goto ehca_reg_mr_rpages_exit1; |
| 1046 | } |
| 1047 | } else { /* rnum==1 */ |
| 1048 | ret = ehca_set_pagebuf_1(e_mr, pginfo, &rpage); |
| 1049 | if (ret) { |
| 1050 | ehca_err(&shca->ib_device, "ehca_set_pagebuf_1 " |
| 1051 | "bad rc, ret=%x i=%x", ret, i); |
| 1052 | ret = -EFAULT; |
| 1053 | goto ehca_reg_mr_rpages_exit1; |
| 1054 | } |
| 1055 | } |
| 1056 | |
| 1057 | h_ret = hipz_h_register_rpage_mr(shca->ipz_hca_handle, e_mr, |
| 1058 | 0, /* pagesize 4k */ |
| 1059 | 0, rpage, rnum); |
| 1060 | |
| 1061 | if (i == ((pginfo->num_4k + 512 - 1) / 512) - 1) { |
| 1062 | /* |
| 1063 | * check for 'registration complete'==H_SUCCESS |
| 1064 | * and for 'page registered'==H_PAGE_REGISTERED |
| 1065 | */ |
| 1066 | if (h_ret != H_SUCCESS) { |
| 1067 | ehca_err(&shca->ib_device, "last " |
| 1068 | "hipz_reg_rpage_mr failed, h_ret=%lx " |
| 1069 | "e_mr=%p i=%x hca_hndl=%lx mr_hndl=%lx" |
| 1070 | " lkey=%x", h_ret, e_mr, i, |
| 1071 | shca->ipz_hca_handle.handle, |
| 1072 | e_mr->ipz_mr_handle.handle, |
| 1073 | e_mr->ib.ib_mr.lkey); |
| 1074 | ret = ehca_mrmw_map_hrc_rrpg_last(h_ret); |
| 1075 | break; |
| 1076 | } else |
| 1077 | ret = 0; |
| 1078 | } else if (h_ret != H_PAGE_REGISTERED) { |
| 1079 | ehca_err(&shca->ib_device, "hipz_reg_rpage_mr failed, " |
| 1080 | "h_ret=%lx e_mr=%p i=%x lkey=%x hca_hndl=%lx " |
| 1081 | "mr_hndl=%lx", h_ret, e_mr, i, |
| 1082 | e_mr->ib.ib_mr.lkey, |
| 1083 | shca->ipz_hca_handle.handle, |
| 1084 | e_mr->ipz_mr_handle.handle); |
| 1085 | ret = ehca_mrmw_map_hrc_rrpg_notlast(h_ret); |
| 1086 | break; |
| 1087 | } else |
| 1088 | ret = 0; |
| 1089 | } /* end for(i) */ |
| 1090 | |
| 1091 | |
| 1092 | ehca_reg_mr_rpages_exit1: |
Hoang-Nam Nguyen | 7e28db5 | 2006-11-07 00:56:39 +0100 | [diff] [blame] | 1093 | ehca_free_fw_ctrlblock(kpage); |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 1094 | ehca_reg_mr_rpages_exit0: |
| 1095 | if (ret) |
| 1096 | ehca_err(&shca->ib_device, "ret=%x shca=%p e_mr=%p pginfo=%p " |
| 1097 | "num_pages=%lx num_4k=%lx", ret, shca, e_mr, pginfo, |
| 1098 | pginfo->num_pages, pginfo->num_4k); |
| 1099 | return ret; |
| 1100 | } /* end ehca_reg_mr_rpages() */ |
| 1101 | |
| 1102 | /*----------------------------------------------------------------------*/ |
| 1103 | |
| 1104 | inline int ehca_rereg_mr_rereg1(struct ehca_shca *shca, |
| 1105 | struct ehca_mr *e_mr, |
| 1106 | u64 *iova_start, |
| 1107 | u64 size, |
| 1108 | u32 acl, |
| 1109 | struct ehca_pd *e_pd, |
| 1110 | struct ehca_mr_pginfo *pginfo, |
| 1111 | u32 *lkey, /*OUT*/ |
| 1112 | u32 *rkey) /*OUT*/ |
| 1113 | { |
| 1114 | int ret; |
| 1115 | u64 h_ret; |
| 1116 | u32 hipz_acl; |
| 1117 | u64 *kpage; |
| 1118 | u64 rpage; |
| 1119 | struct ehca_mr_pginfo pginfo_save; |
| 1120 | struct ehca_mr_hipzout_parms hipzout = {{0},0,0,0,0,0}; |
| 1121 | |
| 1122 | ehca_mrmw_map_acl(acl, &hipz_acl); |
| 1123 | ehca_mrmw_set_pgsize_hipz_acl(&hipz_acl); |
| 1124 | |
Hoang-Nam Nguyen | f2d9136 | 2007-01-09 18:04:14 +0100 | [diff] [blame] | 1125 | kpage = ehca_alloc_fw_ctrlblock(GFP_KERNEL); |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 1126 | if (!kpage) { |
| 1127 | ehca_err(&shca->ib_device, "kpage alloc failed"); |
| 1128 | ret = -ENOMEM; |
| 1129 | goto ehca_rereg_mr_rereg1_exit0; |
| 1130 | } |
| 1131 | |
| 1132 | pginfo_save = *pginfo; |
| 1133 | ret = ehca_set_pagebuf(e_mr, pginfo, pginfo->num_4k, kpage); |
| 1134 | if (ret) { |
| 1135 | ehca_err(&shca->ib_device, "set pagebuf failed, e_mr=%p " |
| 1136 | "pginfo=%p type=%x num_pages=%lx num_4k=%lx kpage=%p", |
| 1137 | e_mr, pginfo, pginfo->type, pginfo->num_pages, |
| 1138 | pginfo->num_4k,kpage); |
| 1139 | goto ehca_rereg_mr_rereg1_exit1; |
| 1140 | } |
| 1141 | rpage = virt_to_abs(kpage); |
| 1142 | if (!rpage) { |
| 1143 | ehca_err(&shca->ib_device, "kpage=%p", kpage); |
| 1144 | ret = -EFAULT; |
| 1145 | goto ehca_rereg_mr_rereg1_exit1; |
| 1146 | } |
| 1147 | h_ret = hipz_h_reregister_pmr(shca->ipz_hca_handle, e_mr, |
| 1148 | (u64)iova_start, size, hipz_acl, |
| 1149 | e_pd->fw_pd, rpage, &hipzout); |
| 1150 | if (h_ret != H_SUCCESS) { |
| 1151 | /* |
| 1152 | * reregistration unsuccessful, try it again with the 3 hCalls, |
| 1153 | * e.g. this is required in case H_MR_CONDITION |
| 1154 | * (MW bound or MR is shared) |
| 1155 | */ |
| 1156 | ehca_warn(&shca->ib_device, "hipz_h_reregister_pmr failed " |
| 1157 | "(Rereg1), h_ret=%lx e_mr=%p", h_ret, e_mr); |
| 1158 | *pginfo = pginfo_save; |
| 1159 | ret = -EAGAIN; |
| 1160 | } else if ((u64*)hipzout.vaddr != iova_start) { |
| 1161 | ehca_err(&shca->ib_device, "PHYP changed iova_start in " |
| 1162 | "rereg_pmr, iova_start=%p iova_start_out=%lx e_mr=%p " |
| 1163 | "mr_handle=%lx lkey=%x lkey_out=%x", iova_start, |
| 1164 | hipzout.vaddr, e_mr, e_mr->ipz_mr_handle.handle, |
| 1165 | e_mr->ib.ib_mr.lkey, hipzout.lkey); |
| 1166 | ret = -EFAULT; |
| 1167 | } else { |
| 1168 | /* |
| 1169 | * successful reregistration |
| 1170 | * note: start and start_out are identical for eServer HCAs |
| 1171 | */ |
| 1172 | e_mr->num_pages = pginfo->num_pages; |
| 1173 | e_mr->num_4k = pginfo->num_4k; |
| 1174 | e_mr->start = iova_start; |
| 1175 | e_mr->size = size; |
| 1176 | e_mr->acl = acl; |
| 1177 | *lkey = hipzout.lkey; |
| 1178 | *rkey = hipzout.rkey; |
| 1179 | } |
| 1180 | |
| 1181 | ehca_rereg_mr_rereg1_exit1: |
Hoang-Nam Nguyen | 7e28db5 | 2006-11-07 00:56:39 +0100 | [diff] [blame] | 1182 | ehca_free_fw_ctrlblock(kpage); |
Heiko J Schick | fab9722 | 2006-09-22 15:22:22 -0700 | [diff] [blame] | 1183 | ehca_rereg_mr_rereg1_exit0: |
| 1184 | if ( ret && (ret != -EAGAIN) ) |
| 1185 | ehca_err(&shca->ib_device, "ret=%x lkey=%x rkey=%x " |
| 1186 | "pginfo=%p num_pages=%lx num_4k=%lx", |
| 1187 | ret, *lkey, *rkey, pginfo, pginfo->num_pages, |
| 1188 | pginfo->num_4k); |
| 1189 | return ret; |
| 1190 | } /* end ehca_rereg_mr_rereg1() */ |
| 1191 | |
| 1192 | /*----------------------------------------------------------------------*/ |
| 1193 | |
| 1194 | int ehca_rereg_mr(struct ehca_shca *shca, |
| 1195 | struct ehca_mr *e_mr, |
| 1196 | u64 *iova_start, |
| 1197 | u64 size, |
| 1198 | int acl, |
| 1199 | struct ehca_pd *e_pd, |
| 1200 | struct ehca_mr_pginfo *pginfo, |
| 1201 | u32 *lkey, |
| 1202 | u32 *rkey) |
| 1203 | { |
| 1204 | int ret = 0; |
| 1205 | u64 h_ret; |
| 1206 | int rereg_1_hcall = 1; /* 1: use hipz_h_reregister_pmr directly */ |
| 1207 | int rereg_3_hcall = 0; /* 1: use 3 hipz calls for reregistration */ |
| 1208 | |
| 1209 | /* first determine reregistration hCall(s) */ |
| 1210 | if ((pginfo->num_4k > 512) || (e_mr->num_4k > 512) || |
| 1211 | (pginfo->num_4k > e_mr->num_4k)) { |
| 1212 | ehca_dbg(&shca->ib_device, "Rereg3 case, pginfo->num_4k=%lx " |
| 1213 | "e_mr->num_4k=%x", pginfo->num_4k, e_mr->num_4k); |
| 1214 | rereg_1_hcall = 0; |
| 1215 | rereg_3_hcall = 1; |
| 1216 | } |
| 1217 | |
| 1218 | if (e_mr->flags & EHCA_MR_FLAG_MAXMR) { /* check for max-MR */ |
| 1219 | rereg_1_hcall = 0; |
| 1220 | rereg_3_hcall = 1; |
| 1221 | e_mr->flags &= ~EHCA_MR_FLAG_MAXMR; |
| 1222 | ehca_err(&shca->ib_device, "Rereg MR for max-MR! e_mr=%p", |
| 1223 | e_mr); |
| 1224 | } |
| 1225 | |
| 1226 | if (rereg_1_hcall) { |
| 1227 | ret = ehca_rereg_mr_rereg1(shca, e_mr, iova_start, size, |
| 1228 | acl, e_pd, pginfo, lkey, rkey); |
| 1229 | if (ret) { |
| 1230 | if (ret == -EAGAIN) |
| 1231 | rereg_3_hcall = 1; |
| 1232 | else |
| 1233 | goto ehca_rereg_mr_exit0; |
| 1234 | } |
| 1235 | } |
| 1236 | |
| 1237 | if (rereg_3_hcall) { |
| 1238 | struct ehca_mr save_mr; |
| 1239 | |
| 1240 | /* first deregister old MR */ |
| 1241 | h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr); |
| 1242 | if (h_ret != H_SUCCESS) { |
| 1243 | ehca_err(&shca->ib_device, "hipz_free_mr failed, " |
| 1244 | "h_ret=%lx e_mr=%p hca_hndl=%lx mr_hndl=%lx " |
| 1245 | "mr->lkey=%x", |
| 1246 | h_ret, e_mr, shca->ipz_hca_handle.handle, |
| 1247 | e_mr->ipz_mr_handle.handle, |
| 1248 | e_mr->ib.ib_mr.lkey); |
| 1249 | ret = ehca_mrmw_map_hrc_free_mr(h_ret); |
| 1250 | goto ehca_rereg_mr_exit0; |
| 1251 | } |
| 1252 | /* clean ehca_mr_t, without changing struct ib_mr and lock */ |
| 1253 | save_mr = *e_mr; |
| 1254 | ehca_mr_deletenew(e_mr); |
| 1255 | |
| 1256 | /* set some MR values */ |
| 1257 | e_mr->flags = save_mr.flags; |
| 1258 | e_mr->fmr_page_size = save_mr.fmr_page_size; |
| 1259 | e_mr->fmr_max_pages = save_mr.fmr_max_pages; |
| 1260 | e_mr->fmr_max_maps = save_mr.fmr_max_maps; |
| 1261 | e_mr->fmr_map_cnt = save_mr.fmr_map_cnt; |
| 1262 | |
| 1263 | ret = ehca_reg_mr(shca, e_mr, iova_start, size, acl, |
| 1264 | e_pd, pginfo, lkey, rkey); |
| 1265 | if (ret) { |
| 1266 | u32 offset = (u64)(&e_mr->flags) - (u64)e_mr; |
| 1267 | memcpy(&e_mr->flags, &(save_mr.flags), |
| 1268 | sizeof(struct ehca_mr) - offset); |
| 1269 | goto ehca_rereg_mr_exit0; |
| 1270 | } |
| 1271 | } |
| 1272 | |
| 1273 | ehca_rereg_mr_exit0: |
| 1274 | if (ret) |
| 1275 | ehca_err(&shca->ib_device, "ret=%x shca=%p e_mr=%p " |
| 1276 | "iova_start=%p size=%lx acl=%x e_pd=%p pginfo=%p " |
| 1277 | "num_pages=%lx lkey=%x rkey=%x rereg_1_hcall=%x " |
| 1278 | "rereg_3_hcall=%x", ret, shca, e_mr, iova_start, size, |
| 1279 | acl, e_pd, pginfo, pginfo->num_pages, *lkey, *rkey, |
| 1280 | rereg_1_hcall, rereg_3_hcall); |
| 1281 | return ret; |
| 1282 | } /* end ehca_rereg_mr() */ |
| 1283 | |
| 1284 | /*----------------------------------------------------------------------*/ |
| 1285 | |
| 1286 | int ehca_unmap_one_fmr(struct ehca_shca *shca, |
| 1287 | struct ehca_mr *e_fmr) |
| 1288 | { |
| 1289 | int ret = 0; |
| 1290 | u64 h_ret; |
| 1291 | int rereg_1_hcall = 1; /* 1: use hipz_mr_reregister directly */ |
| 1292 | int rereg_3_hcall = 0; /* 1: use 3 hipz calls for unmapping */ |
| 1293 | struct ehca_pd *e_pd = |
| 1294 | container_of(e_fmr->ib.ib_fmr.pd, struct ehca_pd, ib_pd); |
| 1295 | struct ehca_mr save_fmr; |
| 1296 | u32 tmp_lkey, tmp_rkey; |
| 1297 | struct ehca_mr_pginfo pginfo={0,0,0,0,0,0,0,NULL,0,NULL,NULL,0,NULL,0}; |
| 1298 | struct ehca_mr_hipzout_parms hipzout = {{0},0,0,0,0,0}; |
| 1299 | |
| 1300 | /* first check if reregistration hCall can be used for unmap */ |
| 1301 | if (e_fmr->fmr_max_pages > 512) { |
| 1302 | rereg_1_hcall = 0; |
| 1303 | rereg_3_hcall = 1; |
| 1304 | } |
| 1305 | |
| 1306 | if (rereg_1_hcall) { |
| 1307 | /* |
| 1308 | * note: after using rereg hcall with len=0, |
| 1309 | * rereg hcall must be used again for registering pages |
| 1310 | */ |
| 1311 | h_ret = hipz_h_reregister_pmr(shca->ipz_hca_handle, e_fmr, 0, |
| 1312 | 0, 0, e_pd->fw_pd, 0, &hipzout); |
| 1313 | if (h_ret != H_SUCCESS) { |
| 1314 | /* |
| 1315 | * should not happen, because length checked above, |
| 1316 | * FMRs are not shared and no MW bound to FMRs |
| 1317 | */ |
| 1318 | ehca_err(&shca->ib_device, "hipz_reregister_pmr failed " |
| 1319 | "(Rereg1), h_ret=%lx e_fmr=%p hca_hndl=%lx " |
| 1320 | "mr_hndl=%lx lkey=%x lkey_out=%x", |
| 1321 | h_ret, e_fmr, shca->ipz_hca_handle.handle, |
| 1322 | e_fmr->ipz_mr_handle.handle, |
| 1323 | e_fmr->ib.ib_fmr.lkey, hipzout.lkey); |
| 1324 | rereg_3_hcall = 1; |
| 1325 | } else { |
| 1326 | /* successful reregistration */ |
| 1327 | e_fmr->start = NULL; |
| 1328 | e_fmr->size = 0; |
| 1329 | tmp_lkey = hipzout.lkey; |
| 1330 | tmp_rkey = hipzout.rkey; |
| 1331 | } |
| 1332 | } |
| 1333 | |
| 1334 | if (rereg_3_hcall) { |
| 1335 | struct ehca_mr save_mr; |
| 1336 | |
| 1337 | /* first free old FMR */ |
| 1338 | h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_fmr); |
| 1339 | if (h_ret != H_SUCCESS) { |
| 1340 | ehca_err(&shca->ib_device, "hipz_free_mr failed, " |
| 1341 | "h_ret=%lx e_fmr=%p hca_hndl=%lx mr_hndl=%lx " |
| 1342 | "lkey=%x", |
| 1343 | h_ret, e_fmr, shca->ipz_hca_handle.handle, |
| 1344 | e_fmr->ipz_mr_handle.handle, |
| 1345 | e_fmr->ib.ib_fmr.lkey); |
| 1346 | ret = ehca_mrmw_map_hrc_free_mr(h_ret); |
| 1347 | goto ehca_unmap_one_fmr_exit0; |
| 1348 | } |
| 1349 | /* clean ehca_mr_t, without changing lock */ |
| 1350 | save_fmr = *e_fmr; |
| 1351 | ehca_mr_deletenew(e_fmr); |
| 1352 | |
| 1353 | /* set some MR values */ |
| 1354 | e_fmr->flags = save_fmr.flags; |
| 1355 | e_fmr->fmr_page_size = save_fmr.fmr_page_size; |
| 1356 | e_fmr->fmr_max_pages = save_fmr.fmr_max_pages; |
| 1357 | e_fmr->fmr_max_maps = save_fmr.fmr_max_maps; |
| 1358 | e_fmr->fmr_map_cnt = save_fmr.fmr_map_cnt; |
| 1359 | e_fmr->acl = save_fmr.acl; |
| 1360 | |
| 1361 | pginfo.type = EHCA_MR_PGI_FMR; |
| 1362 | pginfo.num_pages = 0; |
| 1363 | pginfo.num_4k = 0; |
| 1364 | ret = ehca_reg_mr(shca, e_fmr, NULL, |
| 1365 | (e_fmr->fmr_max_pages * e_fmr->fmr_page_size), |
| 1366 | e_fmr->acl, e_pd, &pginfo, &tmp_lkey, |
| 1367 | &tmp_rkey); |
| 1368 | if (ret) { |
| 1369 | u32 offset = (u64)(&e_fmr->flags) - (u64)e_fmr; |
| 1370 | memcpy(&e_fmr->flags, &(save_mr.flags), |
| 1371 | sizeof(struct ehca_mr) - offset); |
| 1372 | goto ehca_unmap_one_fmr_exit0; |
| 1373 | } |
| 1374 | } |
| 1375 | |
| 1376 | ehca_unmap_one_fmr_exit0: |
| 1377 | if (ret) |
| 1378 | ehca_err(&shca->ib_device, "ret=%x tmp_lkey=%x tmp_rkey=%x " |
| 1379 | "fmr_max_pages=%x rereg_1_hcall=%x rereg_3_hcall=%x", |
| 1380 | ret, tmp_lkey, tmp_rkey, e_fmr->fmr_max_pages, |
| 1381 | rereg_1_hcall, rereg_3_hcall); |
| 1382 | return ret; |
| 1383 | } /* end ehca_unmap_one_fmr() */ |
| 1384 | |
| 1385 | /*----------------------------------------------------------------------*/ |
| 1386 | |
| 1387 | int ehca_reg_smr(struct ehca_shca *shca, |
| 1388 | struct ehca_mr *e_origmr, |
| 1389 | struct ehca_mr *e_newmr, |
| 1390 | u64 *iova_start, |
| 1391 | int acl, |
| 1392 | struct ehca_pd *e_pd, |
| 1393 | u32 *lkey, /*OUT*/ |
| 1394 | u32 *rkey) /*OUT*/ |
| 1395 | { |
| 1396 | int ret = 0; |
| 1397 | u64 h_ret; |
| 1398 | u32 hipz_acl; |
| 1399 | struct ehca_mr_hipzout_parms hipzout = {{0},0,0,0,0,0}; |
| 1400 | |
| 1401 | ehca_mrmw_map_acl(acl, &hipz_acl); |
| 1402 | ehca_mrmw_set_pgsize_hipz_acl(&hipz_acl); |
| 1403 | |
| 1404 | h_ret = hipz_h_register_smr(shca->ipz_hca_handle, e_newmr, e_origmr, |
| 1405 | (u64)iova_start, hipz_acl, e_pd->fw_pd, |
| 1406 | &hipzout); |
| 1407 | if (h_ret != H_SUCCESS) { |
| 1408 | ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%lx " |
| 1409 | "shca=%p e_origmr=%p e_newmr=%p iova_start=%p acl=%x " |
| 1410 | "e_pd=%p hca_hndl=%lx mr_hndl=%lx lkey=%x", |
| 1411 | h_ret, shca, e_origmr, e_newmr, iova_start, acl, e_pd, |
| 1412 | shca->ipz_hca_handle.handle, |
| 1413 | e_origmr->ipz_mr_handle.handle, |
| 1414 | e_origmr->ib.ib_mr.lkey); |
| 1415 | ret = ehca_mrmw_map_hrc_reg_smr(h_ret); |
| 1416 | goto ehca_reg_smr_exit0; |
| 1417 | } |
| 1418 | /* successful registration */ |
| 1419 | e_newmr->num_pages = e_origmr->num_pages; |
| 1420 | e_newmr->num_4k = e_origmr->num_4k; |
| 1421 | e_newmr->start = iova_start; |
| 1422 | e_newmr->size = e_origmr->size; |
| 1423 | e_newmr->acl = acl; |
| 1424 | e_newmr->ipz_mr_handle = hipzout.handle; |
| 1425 | *lkey = hipzout.lkey; |
| 1426 | *rkey = hipzout.rkey; |
| 1427 | return 0; |
| 1428 | |
| 1429 | ehca_reg_smr_exit0: |
| 1430 | if (ret) |
| 1431 | ehca_err(&shca->ib_device, "ret=%x shca=%p e_origmr=%p " |
| 1432 | "e_newmr=%p iova_start=%p acl=%x e_pd=%p", |
| 1433 | ret, shca, e_origmr, e_newmr, iova_start, acl, e_pd); |
| 1434 | return ret; |
| 1435 | } /* end ehca_reg_smr() */ |
| 1436 | |
| 1437 | /*----------------------------------------------------------------------*/ |
| 1438 | |
| 1439 | /* register internal max-MR to internal SHCA */ |
| 1440 | int ehca_reg_internal_maxmr( |
| 1441 | struct ehca_shca *shca, |
| 1442 | struct ehca_pd *e_pd, |
| 1443 | struct ehca_mr **e_maxmr) /*OUT*/ |
| 1444 | { |
| 1445 | int ret; |
| 1446 | struct ehca_mr *e_mr; |
| 1447 | u64 *iova_start; |
| 1448 | u64 size_maxmr; |
| 1449 | struct ehca_mr_pginfo pginfo={0,0,0,0,0,0,0,NULL,0,NULL,NULL,0,NULL,0}; |
| 1450 | struct ib_phys_buf ib_pbuf; |
| 1451 | u32 num_pages_mr; |
| 1452 | u32 num_pages_4k; /* 4k portion "pages" */ |
| 1453 | |
| 1454 | e_mr = ehca_mr_new(); |
| 1455 | if (!e_mr) { |
| 1456 | ehca_err(&shca->ib_device, "out of memory"); |
| 1457 | ret = -ENOMEM; |
| 1458 | goto ehca_reg_internal_maxmr_exit0; |
| 1459 | } |
| 1460 | e_mr->flags |= EHCA_MR_FLAG_MAXMR; |
| 1461 | |
| 1462 | /* register internal max-MR on HCA */ |
| 1463 | size_maxmr = (u64)high_memory - PAGE_OFFSET; |
| 1464 | iova_start = (u64*)KERNELBASE; |
| 1465 | ib_pbuf.addr = 0; |
| 1466 | ib_pbuf.size = size_maxmr; |
| 1467 | num_pages_mr = ((((u64)iova_start % PAGE_SIZE) + size_maxmr + |
| 1468 | PAGE_SIZE - 1) / PAGE_SIZE); |
| 1469 | num_pages_4k = ((((u64)iova_start % EHCA_PAGESIZE) + size_maxmr + |
| 1470 | EHCA_PAGESIZE - 1) / EHCA_PAGESIZE); |
| 1471 | |
| 1472 | pginfo.type = EHCA_MR_PGI_PHYS; |
| 1473 | pginfo.num_pages = num_pages_mr; |
| 1474 | pginfo.num_4k = num_pages_4k; |
| 1475 | pginfo.num_phys_buf = 1; |
| 1476 | pginfo.phys_buf_array = &ib_pbuf; |
| 1477 | |
| 1478 | ret = ehca_reg_mr(shca, e_mr, iova_start, size_maxmr, 0, e_pd, |
| 1479 | &pginfo, &e_mr->ib.ib_mr.lkey, |
| 1480 | &e_mr->ib.ib_mr.rkey); |
| 1481 | if (ret) { |
| 1482 | ehca_err(&shca->ib_device, "reg of internal max MR failed, " |
| 1483 | "e_mr=%p iova_start=%p size_maxmr=%lx num_pages_mr=%x " |
| 1484 | "num_pages_4k=%x", e_mr, iova_start, size_maxmr, |
| 1485 | num_pages_mr, num_pages_4k); |
| 1486 | goto ehca_reg_internal_maxmr_exit1; |
| 1487 | } |
| 1488 | |
| 1489 | /* successful registration of all pages */ |
| 1490 | e_mr->ib.ib_mr.device = e_pd->ib_pd.device; |
| 1491 | e_mr->ib.ib_mr.pd = &e_pd->ib_pd; |
| 1492 | e_mr->ib.ib_mr.uobject = NULL; |
| 1493 | atomic_inc(&(e_pd->ib_pd.usecnt)); |
| 1494 | atomic_set(&(e_mr->ib.ib_mr.usecnt), 0); |
| 1495 | *e_maxmr = e_mr; |
| 1496 | return 0; |
| 1497 | |
| 1498 | ehca_reg_internal_maxmr_exit1: |
| 1499 | ehca_mr_delete(e_mr); |
| 1500 | ehca_reg_internal_maxmr_exit0: |
| 1501 | if (ret) |
| 1502 | ehca_err(&shca->ib_device, "ret=%x shca=%p e_pd=%p e_maxmr=%p", |
| 1503 | ret, shca, e_pd, e_maxmr); |
| 1504 | return ret; |
| 1505 | } /* end ehca_reg_internal_maxmr() */ |
| 1506 | |
| 1507 | /*----------------------------------------------------------------------*/ |
| 1508 | |
| 1509 | int ehca_reg_maxmr(struct ehca_shca *shca, |
| 1510 | struct ehca_mr *e_newmr, |
| 1511 | u64 *iova_start, |
| 1512 | int acl, |
| 1513 | struct ehca_pd *e_pd, |
| 1514 | u32 *lkey, |
| 1515 | u32 *rkey) |
| 1516 | { |
| 1517 | u64 h_ret; |
| 1518 | struct ehca_mr *e_origmr = shca->maxmr; |
| 1519 | u32 hipz_acl; |
| 1520 | struct ehca_mr_hipzout_parms hipzout = {{0},0,0,0,0,0}; |
| 1521 | |
| 1522 | ehca_mrmw_map_acl(acl, &hipz_acl); |
| 1523 | ehca_mrmw_set_pgsize_hipz_acl(&hipz_acl); |
| 1524 | |
| 1525 | h_ret = hipz_h_register_smr(shca->ipz_hca_handle, e_newmr, e_origmr, |
| 1526 | (u64)iova_start, hipz_acl, e_pd->fw_pd, |
| 1527 | &hipzout); |
| 1528 | if (h_ret != H_SUCCESS) { |
| 1529 | ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%lx " |
| 1530 | "e_origmr=%p hca_hndl=%lx mr_hndl=%lx lkey=%x", |
| 1531 | h_ret, e_origmr, shca->ipz_hca_handle.handle, |
| 1532 | e_origmr->ipz_mr_handle.handle, |
| 1533 | e_origmr->ib.ib_mr.lkey); |
| 1534 | return ehca_mrmw_map_hrc_reg_smr(h_ret); |
| 1535 | } |
| 1536 | /* successful registration */ |
| 1537 | e_newmr->num_pages = e_origmr->num_pages; |
| 1538 | e_newmr->num_4k = e_origmr->num_4k; |
| 1539 | e_newmr->start = iova_start; |
| 1540 | e_newmr->size = e_origmr->size; |
| 1541 | e_newmr->acl = acl; |
| 1542 | e_newmr->ipz_mr_handle = hipzout.handle; |
| 1543 | *lkey = hipzout.lkey; |
| 1544 | *rkey = hipzout.rkey; |
| 1545 | return 0; |
| 1546 | } /* end ehca_reg_maxmr() */ |
| 1547 | |
| 1548 | /*----------------------------------------------------------------------*/ |
| 1549 | |
| 1550 | int ehca_dereg_internal_maxmr(struct ehca_shca *shca) |
| 1551 | { |
| 1552 | int ret; |
| 1553 | struct ehca_mr *e_maxmr; |
| 1554 | struct ib_pd *ib_pd; |
| 1555 | |
| 1556 | if (!shca->maxmr) { |
| 1557 | ehca_err(&shca->ib_device, "bad call, shca=%p", shca); |
| 1558 | ret = -EINVAL; |
| 1559 | goto ehca_dereg_internal_maxmr_exit0; |
| 1560 | } |
| 1561 | |
| 1562 | e_maxmr = shca->maxmr; |
| 1563 | ib_pd = e_maxmr->ib.ib_mr.pd; |
| 1564 | shca->maxmr = NULL; /* remove internal max-MR indication from SHCA */ |
| 1565 | |
| 1566 | ret = ehca_dereg_mr(&e_maxmr->ib.ib_mr); |
| 1567 | if (ret) { |
| 1568 | ehca_err(&shca->ib_device, "dereg internal max-MR failed, " |
| 1569 | "ret=%x e_maxmr=%p shca=%p lkey=%x", |
| 1570 | ret, e_maxmr, shca, e_maxmr->ib.ib_mr.lkey); |
| 1571 | shca->maxmr = e_maxmr; |
| 1572 | goto ehca_dereg_internal_maxmr_exit0; |
| 1573 | } |
| 1574 | |
| 1575 | atomic_dec(&ib_pd->usecnt); |
| 1576 | |
| 1577 | ehca_dereg_internal_maxmr_exit0: |
| 1578 | if (ret) |
| 1579 | ehca_err(&shca->ib_device, "ret=%x shca=%p shca->maxmr=%p", |
| 1580 | ret, shca, shca->maxmr); |
| 1581 | return ret; |
| 1582 | } /* end ehca_dereg_internal_maxmr() */ |
| 1583 | |
| 1584 | /*----------------------------------------------------------------------*/ |
| 1585 | |
| 1586 | /* |
| 1587 | * check physical buffer array of MR verbs for validness and |
| 1588 | * calculates MR size |
| 1589 | */ |
| 1590 | int ehca_mr_chk_buf_and_calc_size(struct ib_phys_buf *phys_buf_array, |
| 1591 | int num_phys_buf, |
| 1592 | u64 *iova_start, |
| 1593 | u64 *size) |
| 1594 | { |
| 1595 | struct ib_phys_buf *pbuf = phys_buf_array; |
| 1596 | u64 size_count = 0; |
| 1597 | u32 i; |
| 1598 | |
| 1599 | if (num_phys_buf == 0) { |
| 1600 | ehca_gen_err("bad phys buf array len, num_phys_buf=0"); |
| 1601 | return -EINVAL; |
| 1602 | } |
| 1603 | /* check first buffer */ |
| 1604 | if (((u64)iova_start & ~PAGE_MASK) != (pbuf->addr & ~PAGE_MASK)) { |
| 1605 | ehca_gen_err("iova_start/addr mismatch, iova_start=%p " |
| 1606 | "pbuf->addr=%lx pbuf->size=%lx", |
| 1607 | iova_start, pbuf->addr, pbuf->size); |
| 1608 | return -EINVAL; |
| 1609 | } |
| 1610 | if (((pbuf->addr + pbuf->size) % PAGE_SIZE) && |
| 1611 | (num_phys_buf > 1)) { |
| 1612 | ehca_gen_err("addr/size mismatch in 1st buf, pbuf->addr=%lx " |
| 1613 | "pbuf->size=%lx", pbuf->addr, pbuf->size); |
| 1614 | return -EINVAL; |
| 1615 | } |
| 1616 | |
| 1617 | for (i = 0; i < num_phys_buf; i++) { |
| 1618 | if ((i > 0) && (pbuf->addr % PAGE_SIZE)) { |
| 1619 | ehca_gen_err("bad address, i=%x pbuf->addr=%lx " |
| 1620 | "pbuf->size=%lx", |
| 1621 | i, pbuf->addr, pbuf->size); |
| 1622 | return -EINVAL; |
| 1623 | } |
| 1624 | if (((i > 0) && /* not 1st */ |
| 1625 | (i < (num_phys_buf - 1)) && /* not last */ |
| 1626 | (pbuf->size % PAGE_SIZE)) || (pbuf->size == 0)) { |
| 1627 | ehca_gen_err("bad size, i=%x pbuf->size=%lx", |
| 1628 | i, pbuf->size); |
| 1629 | return -EINVAL; |
| 1630 | } |
| 1631 | size_count += pbuf->size; |
| 1632 | pbuf++; |
| 1633 | } |
| 1634 | |
| 1635 | *size = size_count; |
| 1636 | return 0; |
| 1637 | } /* end ehca_mr_chk_buf_and_calc_size() */ |
| 1638 | |
| 1639 | /*----------------------------------------------------------------------*/ |
| 1640 | |
| 1641 | /* check page list of map FMR verb for validness */ |
| 1642 | int ehca_fmr_check_page_list(struct ehca_mr *e_fmr, |
| 1643 | u64 *page_list, |
| 1644 | int list_len) |
| 1645 | { |
| 1646 | u32 i; |
| 1647 | u64 *page; |
| 1648 | |
| 1649 | if ((list_len == 0) || (list_len > e_fmr->fmr_max_pages)) { |
| 1650 | ehca_gen_err("bad list_len, list_len=%x " |
| 1651 | "e_fmr->fmr_max_pages=%x fmr=%p", |
| 1652 | list_len, e_fmr->fmr_max_pages, e_fmr); |
| 1653 | return -EINVAL; |
| 1654 | } |
| 1655 | |
| 1656 | /* each page must be aligned */ |
| 1657 | page = page_list; |
| 1658 | for (i = 0; i < list_len; i++) { |
| 1659 | if (*page % e_fmr->fmr_page_size) { |
| 1660 | ehca_gen_err("bad page, i=%x *page=%lx page=%p fmr=%p " |
| 1661 | "fmr_page_size=%x", i, *page, page, e_fmr, |
| 1662 | e_fmr->fmr_page_size); |
| 1663 | return -EINVAL; |
| 1664 | } |
| 1665 | page++; |
| 1666 | } |
| 1667 | |
| 1668 | return 0; |
| 1669 | } /* end ehca_fmr_check_page_list() */ |
| 1670 | |
| 1671 | /*----------------------------------------------------------------------*/ |
| 1672 | |
| 1673 | /* setup page buffer from page info */ |
| 1674 | int ehca_set_pagebuf(struct ehca_mr *e_mr, |
| 1675 | struct ehca_mr_pginfo *pginfo, |
| 1676 | u32 number, |
| 1677 | u64 *kpage) |
| 1678 | { |
| 1679 | int ret = 0; |
| 1680 | struct ib_umem_chunk *prev_chunk; |
| 1681 | struct ib_umem_chunk *chunk; |
| 1682 | struct ib_phys_buf *pbuf; |
| 1683 | u64 *fmrlist; |
| 1684 | u64 num4k, pgaddr, offs4k; |
| 1685 | u32 i = 0; |
| 1686 | u32 j = 0; |
| 1687 | |
| 1688 | if (pginfo->type == EHCA_MR_PGI_PHYS) { |
| 1689 | /* loop over desired phys_buf_array entries */ |
| 1690 | while (i < number) { |
| 1691 | pbuf = pginfo->phys_buf_array + pginfo->next_buf; |
| 1692 | num4k = ((pbuf->addr % EHCA_PAGESIZE) + pbuf->size + |
| 1693 | EHCA_PAGESIZE - 1) / EHCA_PAGESIZE; |
| 1694 | offs4k = (pbuf->addr & ~PAGE_MASK) / EHCA_PAGESIZE; |
| 1695 | while (pginfo->next_4k < offs4k + num4k) { |
| 1696 | /* sanity check */ |
| 1697 | if ((pginfo->page_cnt >= pginfo->num_pages) || |
| 1698 | (pginfo->page_4k_cnt >= pginfo->num_4k)) { |
| 1699 | ehca_gen_err("page_cnt >= num_pages, " |
| 1700 | "page_cnt=%lx " |
| 1701 | "num_pages=%lx " |
| 1702 | "page_4k_cnt=%lx " |
| 1703 | "num_4k=%lx i=%x", |
| 1704 | pginfo->page_cnt, |
| 1705 | pginfo->num_pages, |
| 1706 | pginfo->page_4k_cnt, |
| 1707 | pginfo->num_4k, i); |
| 1708 | ret = -EFAULT; |
| 1709 | goto ehca_set_pagebuf_exit0; |
| 1710 | } |
| 1711 | *kpage = phys_to_abs( |
| 1712 | (pbuf->addr & EHCA_PAGEMASK) |
| 1713 | + (pginfo->next_4k * EHCA_PAGESIZE)); |
| 1714 | if ( !(*kpage) && pbuf->addr ) { |
| 1715 | ehca_gen_err("pbuf->addr=%lx " |
| 1716 | "pbuf->size=%lx " |
| 1717 | "next_4k=%lx", pbuf->addr, |
| 1718 | pbuf->size, |
| 1719 | pginfo->next_4k); |
| 1720 | ret = -EFAULT; |
| 1721 | goto ehca_set_pagebuf_exit0; |
| 1722 | } |
| 1723 | (pginfo->page_4k_cnt)++; |
| 1724 | (pginfo->next_4k)++; |
| 1725 | if (pginfo->next_4k % |
| 1726 | (PAGE_SIZE / EHCA_PAGESIZE) == 0) |
| 1727 | (pginfo->page_cnt)++; |
| 1728 | kpage++; |
| 1729 | i++; |
| 1730 | if (i >= number) break; |
| 1731 | } |
| 1732 | if (pginfo->next_4k >= offs4k + num4k) { |
| 1733 | (pginfo->next_buf)++; |
| 1734 | pginfo->next_4k = 0; |
| 1735 | } |
| 1736 | } |
| 1737 | } else if (pginfo->type == EHCA_MR_PGI_USER) { |
| 1738 | /* loop over desired chunk entries */ |
| 1739 | chunk = pginfo->next_chunk; |
| 1740 | prev_chunk = pginfo->next_chunk; |
| 1741 | list_for_each_entry_continue(chunk, |
| 1742 | (&(pginfo->region->chunk_list)), |
| 1743 | list) { |
| 1744 | for (i = pginfo->next_nmap; i < chunk->nmap; ) { |
| 1745 | pgaddr = ( page_to_pfn(chunk->page_list[i].page) |
| 1746 | << PAGE_SHIFT ); |
| 1747 | *kpage = phys_to_abs(pgaddr + |
| 1748 | (pginfo->next_4k * |
| 1749 | EHCA_PAGESIZE)); |
| 1750 | if ( !(*kpage) ) { |
| 1751 | ehca_gen_err("pgaddr=%lx " |
| 1752 | "chunk->page_list[i]=%lx " |
| 1753 | "i=%x next_4k=%lx mr=%p", |
| 1754 | pgaddr, |
| 1755 | (u64)sg_dma_address( |
| 1756 | &chunk-> |
| 1757 | page_list[i]), |
| 1758 | i, pginfo->next_4k, e_mr); |
| 1759 | ret = -EFAULT; |
| 1760 | goto ehca_set_pagebuf_exit0; |
| 1761 | } |
| 1762 | (pginfo->page_4k_cnt)++; |
| 1763 | (pginfo->next_4k)++; |
| 1764 | kpage++; |
| 1765 | if (pginfo->next_4k % |
| 1766 | (PAGE_SIZE / EHCA_PAGESIZE) == 0) { |
| 1767 | (pginfo->page_cnt)++; |
| 1768 | (pginfo->next_nmap)++; |
| 1769 | pginfo->next_4k = 0; |
| 1770 | i++; |
| 1771 | } |
| 1772 | j++; |
| 1773 | if (j >= number) break; |
| 1774 | } |
| 1775 | if ((pginfo->next_nmap >= chunk->nmap) && |
| 1776 | (j >= number)) { |
| 1777 | pginfo->next_nmap = 0; |
| 1778 | prev_chunk = chunk; |
| 1779 | break; |
| 1780 | } else if (pginfo->next_nmap >= chunk->nmap) { |
| 1781 | pginfo->next_nmap = 0; |
| 1782 | prev_chunk = chunk; |
| 1783 | } else if (j >= number) |
| 1784 | break; |
| 1785 | else |
| 1786 | prev_chunk = chunk; |
| 1787 | } |
| 1788 | pginfo->next_chunk = |
| 1789 | list_prepare_entry(prev_chunk, |
| 1790 | (&(pginfo->region->chunk_list)), |
| 1791 | list); |
| 1792 | } else if (pginfo->type == EHCA_MR_PGI_FMR) { |
| 1793 | /* loop over desired page_list entries */ |
| 1794 | fmrlist = pginfo->page_list + pginfo->next_listelem; |
| 1795 | for (i = 0; i < number; i++) { |
| 1796 | *kpage = phys_to_abs((*fmrlist & EHCA_PAGEMASK) + |
| 1797 | pginfo->next_4k * EHCA_PAGESIZE); |
| 1798 | if ( !(*kpage) ) { |
| 1799 | ehca_gen_err("*fmrlist=%lx fmrlist=%p " |
| 1800 | "next_listelem=%lx next_4k=%lx", |
| 1801 | *fmrlist, fmrlist, |
| 1802 | pginfo->next_listelem, |
| 1803 | pginfo->next_4k); |
| 1804 | ret = -EFAULT; |
| 1805 | goto ehca_set_pagebuf_exit0; |
| 1806 | } |
| 1807 | (pginfo->page_4k_cnt)++; |
| 1808 | (pginfo->next_4k)++; |
| 1809 | kpage++; |
| 1810 | if (pginfo->next_4k % |
| 1811 | (e_mr->fmr_page_size / EHCA_PAGESIZE) == 0) { |
| 1812 | (pginfo->page_cnt)++; |
| 1813 | (pginfo->next_listelem)++; |
| 1814 | fmrlist++; |
| 1815 | pginfo->next_4k = 0; |
| 1816 | } |
| 1817 | } |
| 1818 | } else { |
| 1819 | ehca_gen_err("bad pginfo->type=%x", pginfo->type); |
| 1820 | ret = -EFAULT; |
| 1821 | goto ehca_set_pagebuf_exit0; |
| 1822 | } |
| 1823 | |
| 1824 | ehca_set_pagebuf_exit0: |
| 1825 | if (ret) |
| 1826 | ehca_gen_err("ret=%x e_mr=%p pginfo=%p type=%x num_pages=%lx " |
| 1827 | "num_4k=%lx next_buf=%lx next_4k=%lx number=%x " |
| 1828 | "kpage=%p page_cnt=%lx page_4k_cnt=%lx i=%x " |
| 1829 | "next_listelem=%lx region=%p next_chunk=%p " |
| 1830 | "next_nmap=%lx", ret, e_mr, pginfo, pginfo->type, |
| 1831 | pginfo->num_pages, pginfo->num_4k, |
| 1832 | pginfo->next_buf, pginfo->next_4k, number, kpage, |
| 1833 | pginfo->page_cnt, pginfo->page_4k_cnt, i, |
| 1834 | pginfo->next_listelem, pginfo->region, |
| 1835 | pginfo->next_chunk, pginfo->next_nmap); |
| 1836 | return ret; |
| 1837 | } /* end ehca_set_pagebuf() */ |
| 1838 | |
| 1839 | /*----------------------------------------------------------------------*/ |
| 1840 | |
| 1841 | /* setup 1 page from page info page buffer */ |
| 1842 | int ehca_set_pagebuf_1(struct ehca_mr *e_mr, |
| 1843 | struct ehca_mr_pginfo *pginfo, |
| 1844 | u64 *rpage) |
| 1845 | { |
| 1846 | int ret = 0; |
| 1847 | struct ib_phys_buf *tmp_pbuf; |
| 1848 | u64 *fmrlist; |
| 1849 | struct ib_umem_chunk *chunk; |
| 1850 | struct ib_umem_chunk *prev_chunk; |
| 1851 | u64 pgaddr, num4k, offs4k; |
| 1852 | |
| 1853 | if (pginfo->type == EHCA_MR_PGI_PHYS) { |
| 1854 | /* sanity check */ |
| 1855 | if ((pginfo->page_cnt >= pginfo->num_pages) || |
| 1856 | (pginfo->page_4k_cnt >= pginfo->num_4k)) { |
| 1857 | ehca_gen_err("page_cnt >= num_pages, page_cnt=%lx " |
| 1858 | "num_pages=%lx page_4k_cnt=%lx num_4k=%lx", |
| 1859 | pginfo->page_cnt, pginfo->num_pages, |
| 1860 | pginfo->page_4k_cnt, pginfo->num_4k); |
| 1861 | ret = -EFAULT; |
| 1862 | goto ehca_set_pagebuf_1_exit0; |
| 1863 | } |
| 1864 | tmp_pbuf = pginfo->phys_buf_array + pginfo->next_buf; |
| 1865 | num4k = ((tmp_pbuf->addr % EHCA_PAGESIZE) + tmp_pbuf->size + |
| 1866 | EHCA_PAGESIZE - 1) / EHCA_PAGESIZE; |
| 1867 | offs4k = (tmp_pbuf->addr & ~PAGE_MASK) / EHCA_PAGESIZE; |
| 1868 | *rpage = phys_to_abs((tmp_pbuf->addr & EHCA_PAGEMASK) + |
| 1869 | (pginfo->next_4k * EHCA_PAGESIZE)); |
| 1870 | if ( !(*rpage) && tmp_pbuf->addr ) { |
| 1871 | ehca_gen_err("tmp_pbuf->addr=%lx" |
| 1872 | " tmp_pbuf->size=%lx next_4k=%lx", |
| 1873 | tmp_pbuf->addr, tmp_pbuf->size, |
| 1874 | pginfo->next_4k); |
| 1875 | ret = -EFAULT; |
| 1876 | goto ehca_set_pagebuf_1_exit0; |
| 1877 | } |
| 1878 | (pginfo->page_4k_cnt)++; |
| 1879 | (pginfo->next_4k)++; |
| 1880 | if (pginfo->next_4k % (PAGE_SIZE / EHCA_PAGESIZE) == 0) |
| 1881 | (pginfo->page_cnt)++; |
| 1882 | if (pginfo->next_4k >= offs4k + num4k) { |
| 1883 | (pginfo->next_buf)++; |
| 1884 | pginfo->next_4k = 0; |
| 1885 | } |
| 1886 | } else if (pginfo->type == EHCA_MR_PGI_USER) { |
| 1887 | chunk = pginfo->next_chunk; |
| 1888 | prev_chunk = pginfo->next_chunk; |
| 1889 | list_for_each_entry_continue(chunk, |
| 1890 | (&(pginfo->region->chunk_list)), |
| 1891 | list) { |
| 1892 | pgaddr = ( page_to_pfn(chunk->page_list[ |
| 1893 | pginfo->next_nmap].page) |
| 1894 | << PAGE_SHIFT); |
| 1895 | *rpage = phys_to_abs(pgaddr + |
| 1896 | (pginfo->next_4k * EHCA_PAGESIZE)); |
| 1897 | if ( !(*rpage) ) { |
| 1898 | ehca_gen_err("pgaddr=%lx chunk->page_list[]=%lx" |
| 1899 | " next_nmap=%lx next_4k=%lx mr=%p", |
| 1900 | pgaddr, (u64)sg_dma_address( |
| 1901 | &chunk->page_list[ |
| 1902 | pginfo-> |
| 1903 | next_nmap]), |
| 1904 | pginfo->next_nmap, pginfo->next_4k, |
| 1905 | e_mr); |
| 1906 | ret = -EFAULT; |
| 1907 | goto ehca_set_pagebuf_1_exit0; |
| 1908 | } |
| 1909 | (pginfo->page_4k_cnt)++; |
| 1910 | (pginfo->next_4k)++; |
| 1911 | if (pginfo->next_4k % |
| 1912 | (PAGE_SIZE / EHCA_PAGESIZE) == 0) { |
| 1913 | (pginfo->page_cnt)++; |
| 1914 | (pginfo->next_nmap)++; |
| 1915 | pginfo->next_4k = 0; |
| 1916 | } |
| 1917 | if (pginfo->next_nmap >= chunk->nmap) { |
| 1918 | pginfo->next_nmap = 0; |
| 1919 | prev_chunk = chunk; |
| 1920 | } |
| 1921 | break; |
| 1922 | } |
| 1923 | pginfo->next_chunk = |
| 1924 | list_prepare_entry(prev_chunk, |
| 1925 | (&(pginfo->region->chunk_list)), |
| 1926 | list); |
| 1927 | } else if (pginfo->type == EHCA_MR_PGI_FMR) { |
| 1928 | fmrlist = pginfo->page_list + pginfo->next_listelem; |
| 1929 | *rpage = phys_to_abs((*fmrlist & EHCA_PAGEMASK) + |
| 1930 | pginfo->next_4k * EHCA_PAGESIZE); |
| 1931 | if ( !(*rpage) ) { |
| 1932 | ehca_gen_err("*fmrlist=%lx fmrlist=%p " |
| 1933 | "next_listelem=%lx next_4k=%lx", |
| 1934 | *fmrlist, fmrlist, pginfo->next_listelem, |
| 1935 | pginfo->next_4k); |
| 1936 | ret = -EFAULT; |
| 1937 | goto ehca_set_pagebuf_1_exit0; |
| 1938 | } |
| 1939 | (pginfo->page_4k_cnt)++; |
| 1940 | (pginfo->next_4k)++; |
| 1941 | if (pginfo->next_4k % |
| 1942 | (e_mr->fmr_page_size / EHCA_PAGESIZE) == 0) { |
| 1943 | (pginfo->page_cnt)++; |
| 1944 | (pginfo->next_listelem)++; |
| 1945 | pginfo->next_4k = 0; |
| 1946 | } |
| 1947 | } else { |
| 1948 | ehca_gen_err("bad pginfo->type=%x", pginfo->type); |
| 1949 | ret = -EFAULT; |
| 1950 | goto ehca_set_pagebuf_1_exit0; |
| 1951 | } |
| 1952 | |
| 1953 | ehca_set_pagebuf_1_exit0: |
| 1954 | if (ret) |
| 1955 | ehca_gen_err("ret=%x e_mr=%p pginfo=%p type=%x num_pages=%lx " |
| 1956 | "num_4k=%lx next_buf=%lx next_4k=%lx rpage=%p " |
| 1957 | "page_cnt=%lx page_4k_cnt=%lx next_listelem=%lx " |
| 1958 | "region=%p next_chunk=%p next_nmap=%lx", ret, e_mr, |
| 1959 | pginfo, pginfo->type, pginfo->num_pages, |
| 1960 | pginfo->num_4k, pginfo->next_buf, pginfo->next_4k, |
| 1961 | rpage, pginfo->page_cnt, pginfo->page_4k_cnt, |
| 1962 | pginfo->next_listelem, pginfo->region, |
| 1963 | pginfo->next_chunk, pginfo->next_nmap); |
| 1964 | return ret; |
| 1965 | } /* end ehca_set_pagebuf_1() */ |
| 1966 | |
| 1967 | /*----------------------------------------------------------------------*/ |
| 1968 | |
| 1969 | /* |
| 1970 | * check MR if it is a max-MR, i.e. uses whole memory |
| 1971 | * in case it's a max-MR 1 is returned, else 0 |
| 1972 | */ |
| 1973 | int ehca_mr_is_maxmr(u64 size, |
| 1974 | u64 *iova_start) |
| 1975 | { |
| 1976 | /* a MR is treated as max-MR only if it fits following: */ |
| 1977 | if ((size == ((u64)high_memory - PAGE_OFFSET)) && |
| 1978 | (iova_start == (void*)KERNELBASE)) { |
| 1979 | ehca_gen_dbg("this is a max-MR"); |
| 1980 | return 1; |
| 1981 | } else |
| 1982 | return 0; |
| 1983 | } /* end ehca_mr_is_maxmr() */ |
| 1984 | |
| 1985 | /*----------------------------------------------------------------------*/ |
| 1986 | |
| 1987 | /* map access control for MR/MW. This routine is used for MR and MW. */ |
| 1988 | void ehca_mrmw_map_acl(int ib_acl, |
| 1989 | u32 *hipz_acl) |
| 1990 | { |
| 1991 | *hipz_acl = 0; |
| 1992 | if (ib_acl & IB_ACCESS_REMOTE_READ) |
| 1993 | *hipz_acl |= HIPZ_ACCESSCTRL_R_READ; |
| 1994 | if (ib_acl & IB_ACCESS_REMOTE_WRITE) |
| 1995 | *hipz_acl |= HIPZ_ACCESSCTRL_R_WRITE; |
| 1996 | if (ib_acl & IB_ACCESS_REMOTE_ATOMIC) |
| 1997 | *hipz_acl |= HIPZ_ACCESSCTRL_R_ATOMIC; |
| 1998 | if (ib_acl & IB_ACCESS_LOCAL_WRITE) |
| 1999 | *hipz_acl |= HIPZ_ACCESSCTRL_L_WRITE; |
| 2000 | if (ib_acl & IB_ACCESS_MW_BIND) |
| 2001 | *hipz_acl |= HIPZ_ACCESSCTRL_MW_BIND; |
| 2002 | } /* end ehca_mrmw_map_acl() */ |
| 2003 | |
| 2004 | /*----------------------------------------------------------------------*/ |
| 2005 | |
| 2006 | /* sets page size in hipz access control for MR/MW. */ |
| 2007 | void ehca_mrmw_set_pgsize_hipz_acl(u32 *hipz_acl) /*INOUT*/ |
| 2008 | { |
| 2009 | return; /* HCA supports only 4k */ |
| 2010 | } /* end ehca_mrmw_set_pgsize_hipz_acl() */ |
| 2011 | |
| 2012 | /*----------------------------------------------------------------------*/ |
| 2013 | |
| 2014 | /* |
| 2015 | * reverse map access control for MR/MW. |
| 2016 | * This routine is used for MR and MW. |
| 2017 | */ |
| 2018 | void ehca_mrmw_reverse_map_acl(const u32 *hipz_acl, |
| 2019 | int *ib_acl) /*OUT*/ |
| 2020 | { |
| 2021 | *ib_acl = 0; |
| 2022 | if (*hipz_acl & HIPZ_ACCESSCTRL_R_READ) |
| 2023 | *ib_acl |= IB_ACCESS_REMOTE_READ; |
| 2024 | if (*hipz_acl & HIPZ_ACCESSCTRL_R_WRITE) |
| 2025 | *ib_acl |= IB_ACCESS_REMOTE_WRITE; |
| 2026 | if (*hipz_acl & HIPZ_ACCESSCTRL_R_ATOMIC) |
| 2027 | *ib_acl |= IB_ACCESS_REMOTE_ATOMIC; |
| 2028 | if (*hipz_acl & HIPZ_ACCESSCTRL_L_WRITE) |
| 2029 | *ib_acl |= IB_ACCESS_LOCAL_WRITE; |
| 2030 | if (*hipz_acl & HIPZ_ACCESSCTRL_MW_BIND) |
| 2031 | *ib_acl |= IB_ACCESS_MW_BIND; |
| 2032 | } /* end ehca_mrmw_reverse_map_acl() */ |
| 2033 | |
| 2034 | |
| 2035 | /*----------------------------------------------------------------------*/ |
| 2036 | |
| 2037 | /* |
| 2038 | * map HIPZ rc to IB retcodes for MR/MW allocations |
| 2039 | * Used for hipz_mr_reg_alloc and hipz_mw_alloc. |
| 2040 | */ |
| 2041 | int ehca_mrmw_map_hrc_alloc(const u64 hipz_rc) |
| 2042 | { |
| 2043 | switch (hipz_rc) { |
| 2044 | case H_SUCCESS: /* successful completion */ |
| 2045 | return 0; |
| 2046 | case H_ADAPTER_PARM: /* invalid adapter handle */ |
| 2047 | case H_RT_PARM: /* invalid resource type */ |
| 2048 | case H_NOT_ENOUGH_RESOURCES: /* insufficient resources */ |
| 2049 | case H_MLENGTH_PARM: /* invalid memory length */ |
| 2050 | case H_MEM_ACCESS_PARM: /* invalid access controls */ |
| 2051 | case H_CONSTRAINED: /* resource constraint */ |
| 2052 | return -EINVAL; |
| 2053 | case H_BUSY: /* long busy */ |
| 2054 | return -EBUSY; |
| 2055 | default: |
| 2056 | return -EINVAL; |
| 2057 | } |
| 2058 | } /* end ehca_mrmw_map_hrc_alloc() */ |
| 2059 | |
| 2060 | /*----------------------------------------------------------------------*/ |
| 2061 | |
| 2062 | /* |
| 2063 | * map HIPZ rc to IB retcodes for MR register rpage |
| 2064 | * Used for hipz_h_register_rpage_mr at registering last page |
| 2065 | */ |
| 2066 | int ehca_mrmw_map_hrc_rrpg_last(const u64 hipz_rc) |
| 2067 | { |
| 2068 | switch (hipz_rc) { |
| 2069 | case H_SUCCESS: /* registration complete */ |
| 2070 | return 0; |
| 2071 | case H_PAGE_REGISTERED: /* page registered */ |
| 2072 | case H_ADAPTER_PARM: /* invalid adapter handle */ |
| 2073 | case H_RH_PARM: /* invalid resource handle */ |
| 2074 | /* case H_QT_PARM: invalid queue type */ |
| 2075 | case H_PARAMETER: /* |
| 2076 | * invalid logical address, |
| 2077 | * or count zero or greater 512 |
| 2078 | */ |
| 2079 | case H_TABLE_FULL: /* page table full */ |
| 2080 | case H_HARDWARE: /* HCA not operational */ |
| 2081 | return -EINVAL; |
| 2082 | case H_BUSY: /* long busy */ |
| 2083 | return -EBUSY; |
| 2084 | default: |
| 2085 | return -EINVAL; |
| 2086 | } |
| 2087 | } /* end ehca_mrmw_map_hrc_rrpg_last() */ |
| 2088 | |
| 2089 | /*----------------------------------------------------------------------*/ |
| 2090 | |
| 2091 | /* |
| 2092 | * map HIPZ rc to IB retcodes for MR register rpage |
| 2093 | * Used for hipz_h_register_rpage_mr at registering one page, but not last page |
| 2094 | */ |
| 2095 | int ehca_mrmw_map_hrc_rrpg_notlast(const u64 hipz_rc) |
| 2096 | { |
| 2097 | switch (hipz_rc) { |
| 2098 | case H_PAGE_REGISTERED: /* page registered */ |
| 2099 | return 0; |
| 2100 | case H_SUCCESS: /* registration complete */ |
| 2101 | case H_ADAPTER_PARM: /* invalid adapter handle */ |
| 2102 | case H_RH_PARM: /* invalid resource handle */ |
| 2103 | /* case H_QT_PARM: invalid queue type */ |
| 2104 | case H_PARAMETER: /* |
| 2105 | * invalid logical address, |
| 2106 | * or count zero or greater 512 |
| 2107 | */ |
| 2108 | case H_TABLE_FULL: /* page table full */ |
| 2109 | case H_HARDWARE: /* HCA not operational */ |
| 2110 | return -EINVAL; |
| 2111 | case H_BUSY: /* long busy */ |
| 2112 | return -EBUSY; |
| 2113 | default: |
| 2114 | return -EINVAL; |
| 2115 | } |
| 2116 | } /* end ehca_mrmw_map_hrc_rrpg_notlast() */ |
| 2117 | |
| 2118 | /*----------------------------------------------------------------------*/ |
| 2119 | |
| 2120 | /* map HIPZ rc to IB retcodes for MR query. Used for hipz_mr_query. */ |
| 2121 | int ehca_mrmw_map_hrc_query_mr(const u64 hipz_rc) |
| 2122 | { |
| 2123 | switch (hipz_rc) { |
| 2124 | case H_SUCCESS: /* successful completion */ |
| 2125 | return 0; |
| 2126 | case H_ADAPTER_PARM: /* invalid adapter handle */ |
| 2127 | case H_RH_PARM: /* invalid resource handle */ |
| 2128 | return -EINVAL; |
| 2129 | case H_BUSY: /* long busy */ |
| 2130 | return -EBUSY; |
| 2131 | default: |
| 2132 | return -EINVAL; |
| 2133 | } |
| 2134 | } /* end ehca_mrmw_map_hrc_query_mr() */ |
| 2135 | |
| 2136 | /*----------------------------------------------------------------------*/ |
| 2137 | /*----------------------------------------------------------------------*/ |
| 2138 | |
| 2139 | /* |
| 2140 | * map HIPZ rc to IB retcodes for freeing MR resource |
| 2141 | * Used for hipz_h_free_resource_mr |
| 2142 | */ |
| 2143 | int ehca_mrmw_map_hrc_free_mr(const u64 hipz_rc) |
| 2144 | { |
| 2145 | switch (hipz_rc) { |
| 2146 | case H_SUCCESS: /* resource freed */ |
| 2147 | return 0; |
| 2148 | case H_ADAPTER_PARM: /* invalid adapter handle */ |
| 2149 | case H_RH_PARM: /* invalid resource handle */ |
| 2150 | case H_R_STATE: /* invalid resource state */ |
| 2151 | case H_HARDWARE: /* HCA not operational */ |
| 2152 | return -EINVAL; |
| 2153 | case H_RESOURCE: /* Resource in use */ |
| 2154 | case H_BUSY: /* long busy */ |
| 2155 | return -EBUSY; |
| 2156 | default: |
| 2157 | return -EINVAL; |
| 2158 | } |
| 2159 | } /* end ehca_mrmw_map_hrc_free_mr() */ |
| 2160 | |
| 2161 | /*----------------------------------------------------------------------*/ |
| 2162 | |
| 2163 | /* |
| 2164 | * map HIPZ rc to IB retcodes for freeing MW resource |
| 2165 | * Used for hipz_h_free_resource_mw |
| 2166 | */ |
| 2167 | int ehca_mrmw_map_hrc_free_mw(const u64 hipz_rc) |
| 2168 | { |
| 2169 | switch (hipz_rc) { |
| 2170 | case H_SUCCESS: /* resource freed */ |
| 2171 | return 0; |
| 2172 | case H_ADAPTER_PARM: /* invalid adapter handle */ |
| 2173 | case H_RH_PARM: /* invalid resource handle */ |
| 2174 | case H_R_STATE: /* invalid resource state */ |
| 2175 | case H_HARDWARE: /* HCA not operational */ |
| 2176 | return -EINVAL; |
| 2177 | case H_RESOURCE: /* Resource in use */ |
| 2178 | case H_BUSY: /* long busy */ |
| 2179 | return -EBUSY; |
| 2180 | default: |
| 2181 | return -EINVAL; |
| 2182 | } |
| 2183 | } /* end ehca_mrmw_map_hrc_free_mw() */ |
| 2184 | |
| 2185 | /*----------------------------------------------------------------------*/ |
| 2186 | |
| 2187 | /* |
| 2188 | * map HIPZ rc to IB retcodes for SMR registrations |
| 2189 | * Used for hipz_h_register_smr. |
| 2190 | */ |
| 2191 | int ehca_mrmw_map_hrc_reg_smr(const u64 hipz_rc) |
| 2192 | { |
| 2193 | switch (hipz_rc) { |
| 2194 | case H_SUCCESS: /* successful completion */ |
| 2195 | return 0; |
| 2196 | case H_ADAPTER_PARM: /* invalid adapter handle */ |
| 2197 | case H_RH_PARM: /* invalid resource handle */ |
| 2198 | case H_MEM_PARM: /* invalid MR virtual address */ |
| 2199 | case H_MEM_ACCESS_PARM: /* invalid access controls */ |
| 2200 | case H_NOT_ENOUGH_RESOURCES: /* insufficient resources */ |
| 2201 | return -EINVAL; |
| 2202 | case H_BUSY: /* long busy */ |
| 2203 | return -EBUSY; |
| 2204 | default: |
| 2205 | return -EINVAL; |
| 2206 | } |
| 2207 | } /* end ehca_mrmw_map_hrc_reg_smr() */ |
| 2208 | |
| 2209 | /*----------------------------------------------------------------------*/ |
| 2210 | |
| 2211 | /* |
| 2212 | * MR destructor and constructor |
| 2213 | * used in Reregister MR verb, sets all fields in ehca_mr_t to 0, |
| 2214 | * except struct ib_mr and spinlock |
| 2215 | */ |
| 2216 | void ehca_mr_deletenew(struct ehca_mr *mr) |
| 2217 | { |
| 2218 | mr->flags = 0; |
| 2219 | mr->num_pages = 0; |
| 2220 | mr->num_4k = 0; |
| 2221 | mr->acl = 0; |
| 2222 | mr->start = NULL; |
| 2223 | mr->fmr_page_size = 0; |
| 2224 | mr->fmr_max_pages = 0; |
| 2225 | mr->fmr_max_maps = 0; |
| 2226 | mr->fmr_map_cnt = 0; |
| 2227 | memset(&mr->ipz_mr_handle, 0, sizeof(mr->ipz_mr_handle)); |
| 2228 | memset(&mr->galpas, 0, sizeof(mr->galpas)); |
| 2229 | mr->nr_of_pages = 0; |
| 2230 | mr->pagearray = NULL; |
| 2231 | } /* end ehca_mr_deletenew() */ |
| 2232 | |
| 2233 | int ehca_init_mrmw_cache(void) |
| 2234 | { |
| 2235 | mr_cache = kmem_cache_create("ehca_cache_mr", |
| 2236 | sizeof(struct ehca_mr), 0, |
| 2237 | SLAB_HWCACHE_ALIGN, |
| 2238 | NULL, NULL); |
| 2239 | if (!mr_cache) |
| 2240 | return -ENOMEM; |
| 2241 | mw_cache = kmem_cache_create("ehca_cache_mw", |
| 2242 | sizeof(struct ehca_mw), 0, |
| 2243 | SLAB_HWCACHE_ALIGN, |
| 2244 | NULL, NULL); |
| 2245 | if (!mw_cache) { |
| 2246 | kmem_cache_destroy(mr_cache); |
| 2247 | mr_cache = NULL; |
| 2248 | return -ENOMEM; |
| 2249 | } |
| 2250 | return 0; |
| 2251 | } |
| 2252 | |
| 2253 | void ehca_cleanup_mrmw_cache(void) |
| 2254 | { |
| 2255 | if (mr_cache) |
| 2256 | kmem_cache_destroy(mr_cache); |
| 2257 | if (mw_cache) |
| 2258 | kmem_cache_destroy(mw_cache); |
| 2259 | } |