/arch/powerpc/platforms/ps3/mm.c
C | 1237 lines | 848 code | 203 blank | 186 comment | 69 complexity | 0b956ded064f5ac93e33341fa9b3fa08 MD5 | raw file
1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * PS3 address space management. 4 * 5 * Copyright (C) 2006 Sony Computer Entertainment Inc. 6 * Copyright 2006 Sony Corp. 7 */ 8 9#include <linux/kernel.h> 10#include <linux/export.h> 11#include <linux/memblock.h> 12#include <linux/slab.h> 13 14#include <asm/cell-regs.h> 15#include <asm/firmware.h> 16#include <asm/prom.h> 17#include <asm/udbg.h> 18#include <asm/lv1call.h> 19#include <asm/setup.h> 20 21#include "platform.h" 22 23#if defined(DEBUG) 24#define DBG udbg_printf 25#else 26#define DBG pr_devel 27#endif 28 29enum { 30#if defined(CONFIG_PS3_DYNAMIC_DMA) 31 USE_DYNAMIC_DMA = 1, 32#else 33 USE_DYNAMIC_DMA = 0, 34#endif 35}; 36 37enum { 38 PAGE_SHIFT_4K = 12U, 39 PAGE_SHIFT_64K = 16U, 40 PAGE_SHIFT_16M = 24U, 41}; 42 43static unsigned long make_page_sizes(unsigned long a, unsigned long b) 44{ 45 return (a << 56) | (b << 48); 46} 47 48enum { 49 ALLOCATE_MEMORY_TRY_ALT_UNIT = 0X04, 50 ALLOCATE_MEMORY_ADDR_ZERO = 0X08, 51}; 52 53/* valid htab sizes are {18,19,20} = 256K, 512K, 1M */ 54 55enum { 56 HTAB_SIZE_MAX = 20U, /* HV limit of 1MB */ 57 HTAB_SIZE_MIN = 18U, /* CPU limit of 256KB */ 58}; 59 60/*============================================================================*/ 61/* virtual address space routines */ 62/*============================================================================*/ 63 64/** 65 * struct mem_region - memory region structure 66 * @base: base address 67 * @size: size in bytes 68 * @offset: difference between base and rm.size 69 * @destroy: flag if region should be destroyed upon shutdown 70 */ 71 72struct mem_region { 73 u64 base; 74 u64 size; 75 unsigned long offset; 76 int destroy; 77}; 78 79/** 80 * struct map - address space state variables holder 81 * @total: total memory available as reported by HV 82 * @vas_id - HV virtual address space id 83 * @htab_size: htab size in bytes 84 * 85 * The HV virtual address space (vas) allows for hotplug memory regions. 86 * Memory regions can be created and destroyed in the vas at runtime. 87 * @rm: real mode (bootmem) region 88 * @r1: highmem region(s) 89 * 90 * ps3 addresses 91 * virt_addr: a cpu 'translated' effective address 92 * phys_addr: an address in what Linux thinks is the physical address space 93 * lpar_addr: an address in the HV virtual address space 94 * bus_addr: an io controller 'translated' address on a device bus 95 */ 96 97struct map { 98 u64 total; 99 u64 vas_id; 100 u64 htab_size; 101 struct mem_region rm; 102 struct mem_region r1; 103}; 104 105#define debug_dump_map(x) _debug_dump_map(x, __func__, __LINE__) 106static void __maybe_unused _debug_dump_map(const struct map *m, 107 const char *func, int line) 108{ 109 DBG("%s:%d: map.total = %llxh\n", func, line, m->total); 110 DBG("%s:%d: map.rm.size = %llxh\n", func, line, m->rm.size); 111 DBG("%s:%d: map.vas_id = %llu\n", func, line, m->vas_id); 112 DBG("%s:%d: map.htab_size = %llxh\n", func, line, m->htab_size); 113 DBG("%s:%d: map.r1.base = %llxh\n", func, line, m->r1.base); 114 DBG("%s:%d: map.r1.offset = %lxh\n", func, line, m->r1.offset); 115 DBG("%s:%d: map.r1.size = %llxh\n", func, line, m->r1.size); 116} 117 118static struct map map; 119 120/** 121 * ps3_mm_phys_to_lpar - translate a linux physical address to lpar address 122 * @phys_addr: linux physical address 123 */ 124 125unsigned long ps3_mm_phys_to_lpar(unsigned long phys_addr) 126{ 127 BUG_ON(is_kernel_addr(phys_addr)); 128 return (phys_addr < map.rm.size || phys_addr >= map.total) 129 ? phys_addr : phys_addr + map.r1.offset; 130} 131 132EXPORT_SYMBOL(ps3_mm_phys_to_lpar); 133 134/** 135 * ps3_mm_vas_create - create the virtual address space 136 */ 137 138void __init ps3_mm_vas_create(unsigned long* htab_size) 139{ 140 int result; 141 u64 start_address; 142 u64 size; 143 u64 access_right; 144 u64 max_page_size; 145 u64 flags; 146 147 result = lv1_query_logical_partition_address_region_info(0, 148 &start_address, &size, &access_right, &max_page_size, 149 &flags); 150 151 if (result) { 152 DBG("%s:%d: lv1_query_logical_partition_address_region_info " 153 "failed: %s\n", __func__, __LINE__, 154 ps3_result(result)); 155 goto fail; 156 } 157 158 if (max_page_size < PAGE_SHIFT_16M) { 159 DBG("%s:%d: bad max_page_size %llxh\n", __func__, __LINE__, 160 max_page_size); 161 goto fail; 162 } 163 164 BUILD_BUG_ON(CONFIG_PS3_HTAB_SIZE > HTAB_SIZE_MAX); 165 BUILD_BUG_ON(CONFIG_PS3_HTAB_SIZE < HTAB_SIZE_MIN); 166 167 result = lv1_construct_virtual_address_space(CONFIG_PS3_HTAB_SIZE, 168 2, make_page_sizes(PAGE_SHIFT_16M, PAGE_SHIFT_64K), 169 &map.vas_id, &map.htab_size); 170 171 if (result) { 172 DBG("%s:%d: lv1_construct_virtual_address_space failed: %s\n", 173 __func__, __LINE__, ps3_result(result)); 174 goto fail; 175 } 176 177 result = lv1_select_virtual_address_space(map.vas_id); 178 179 if (result) { 180 DBG("%s:%d: lv1_select_virtual_address_space failed: %s\n", 181 __func__, __LINE__, ps3_result(result)); 182 goto fail; 183 } 184 185 *htab_size = map.htab_size; 186 187 debug_dump_map(&map); 188 189 return; 190 191fail: 192 panic("ps3_mm_vas_create failed"); 193} 194 195/** 196 * ps3_mm_vas_destroy - 197 */ 198 199void ps3_mm_vas_destroy(void) 200{ 201 int result; 202 203 DBG("%s:%d: map.vas_id = %llu\n", __func__, __LINE__, map.vas_id); 204 205 if (map.vas_id) { 206 result = lv1_select_virtual_address_space(0); 207 BUG_ON(result); 208 result = lv1_destruct_virtual_address_space(map.vas_id); 209 BUG_ON(result); 210 map.vas_id = 0; 211 } 212} 213 214static int ps3_mm_get_repository_highmem(struct mem_region *r) 215{ 216 int result; 217 218 /* Assume a single highmem region. */ 219 220 result = ps3_repository_read_highmem_info(0, &r->base, &r->size); 221 222 if (result) 223 goto zero_region; 224 225 if (!r->base || !r->size) { 226 result = -1; 227 goto zero_region; 228 } 229 230 r->offset = r->base - map.rm.size; 231 232 DBG("%s:%d: Found high region in repository: %llxh %llxh\n", 233 __func__, __LINE__, r->base, r->size); 234 235 return 0; 236 237zero_region: 238 DBG("%s:%d: No high region in repository.\n", __func__, __LINE__); 239 240 r->size = r->base = r->offset = 0; 241 return result; 242} 243 244static int ps3_mm_set_repository_highmem(const struct mem_region *r) 245{ 246 /* Assume a single highmem region. */ 247 248 return r ? ps3_repository_write_highmem_info(0, r->base, r->size) : 249 ps3_repository_write_highmem_info(0, 0, 0); 250} 251 252/** 253 * ps3_mm_region_create - create a memory region in the vas 254 * @r: pointer to a struct mem_region to accept initialized values 255 * @size: requested region size 256 * 257 * This implementation creates the region with the vas large page size. 258 * @size is rounded down to a multiple of the vas large page size. 259 */ 260 261static int ps3_mm_region_create(struct mem_region *r, unsigned long size) 262{ 263 int result; 264 u64 muid; 265 266 r->size = _ALIGN_DOWN(size, 1 << PAGE_SHIFT_16M); 267 268 DBG("%s:%d requested %lxh\n", __func__, __LINE__, size); 269 DBG("%s:%d actual %llxh\n", __func__, __LINE__, r->size); 270 DBG("%s:%d difference %llxh (%lluMB)\n", __func__, __LINE__, 271 size - r->size, (size - r->size) / 1024 / 1024); 272 273 if (r->size == 0) { 274 DBG("%s:%d: size == 0\n", __func__, __LINE__); 275 result = -1; 276 goto zero_region; 277 } 278 279 result = lv1_allocate_memory(r->size, PAGE_SHIFT_16M, 0, 280 ALLOCATE_MEMORY_TRY_ALT_UNIT, &r->base, &muid); 281 282 if (result || r->base < map.rm.size) { 283 DBG("%s:%d: lv1_allocate_memory failed: %s\n", 284 __func__, __LINE__, ps3_result(result)); 285 goto zero_region; 286 } 287 288 r->destroy = 1; 289 r->offset = r->base - map.rm.size; 290 return result; 291 292zero_region: 293 r->size = r->base = r->offset = 0; 294 return result; 295} 296 297/** 298 * ps3_mm_region_destroy - destroy a memory region 299 * @r: pointer to struct mem_region 300 */ 301 302static void ps3_mm_region_destroy(struct mem_region *r) 303{ 304 int result; 305 306 if (!r->destroy) { 307 pr_info("%s:%d: Not destroying high region: %llxh %llxh\n", 308 __func__, __LINE__, r->base, r->size); 309 return; 310 } 311 312 DBG("%s:%d: r->base = %llxh\n", __func__, __LINE__, r->base); 313 314 if (r->base) { 315 result = lv1_release_memory(r->base); 316 BUG_ON(result); 317 r->size = r->base = r->offset = 0; 318 map.total = map.rm.size; 319 } 320 ps3_mm_set_repository_highmem(NULL); 321} 322 323/*============================================================================*/ 324/* dma routines */ 325/*============================================================================*/ 326 327/** 328 * dma_sb_lpar_to_bus - Translate an lpar address to ioc mapped bus address. 329 * @r: pointer to dma region structure 330 * @lpar_addr: HV lpar address 331 */ 332 333static unsigned long dma_sb_lpar_to_bus(struct ps3_dma_region *r, 334 unsigned long lpar_addr) 335{ 336 if (lpar_addr >= map.rm.size) 337 lpar_addr -= map.r1.offset; 338 BUG_ON(lpar_addr < r->offset); 339 BUG_ON(lpar_addr >= r->offset + r->len); 340 return r->bus_addr + lpar_addr - r->offset; 341} 342 343#define dma_dump_region(_a) _dma_dump_region(_a, __func__, __LINE__) 344static void __maybe_unused _dma_dump_region(const struct ps3_dma_region *r, 345 const char *func, int line) 346{ 347 DBG("%s:%d: dev %llu:%llu\n", func, line, r->dev->bus_id, 348 r->dev->dev_id); 349 DBG("%s:%d: page_size %u\n", func, line, r->page_size); 350 DBG("%s:%d: bus_addr %lxh\n", func, line, r->bus_addr); 351 DBG("%s:%d: len %lxh\n", func, line, r->len); 352 DBG("%s:%d: offset %lxh\n", func, line, r->offset); 353} 354 355 /** 356 * dma_chunk - A chunk of dma pages mapped by the io controller. 357 * @region - The dma region that owns this chunk. 358 * @lpar_addr: Starting lpar address of the area to map. 359 * @bus_addr: Starting ioc bus address of the area to map. 360 * @len: Length in bytes of the area to map. 361 * @link: A struct list_head used with struct ps3_dma_region.chunk_list, the 362 * list of all chuncks owned by the region. 363 * 364 * This implementation uses a very simple dma page manager 365 * based on the dma_chunk structure. This scheme assumes 366 * that all drivers use very well behaved dma ops. 367 */ 368 369struct dma_chunk { 370 struct ps3_dma_region *region; 371 unsigned long lpar_addr; 372 unsigned long bus_addr; 373 unsigned long len; 374 struct list_head link; 375 unsigned int usage_count; 376}; 377 378#define dma_dump_chunk(_a) _dma_dump_chunk(_a, __func__, __LINE__) 379static void _dma_dump_chunk (const struct dma_chunk* c, const char* func, 380 int line) 381{ 382 DBG("%s:%d: r.dev %llu:%llu\n", func, line, 383 c->region->dev->bus_id, c->region->dev->dev_id); 384 DBG("%s:%d: r.bus_addr %lxh\n", func, line, c->region->bus_addr); 385 DBG("%s:%d: r.page_size %u\n", func, line, c->region->page_size); 386 DBG("%s:%d: r.len %lxh\n", func, line, c->region->len); 387 DBG("%s:%d: r.offset %lxh\n", func, line, c->region->offset); 388 DBG("%s:%d: c.lpar_addr %lxh\n", func, line, c->lpar_addr); 389 DBG("%s:%d: c.bus_addr %lxh\n", func, line, c->bus_addr); 390 DBG("%s:%d: c.len %lxh\n", func, line, c->len); 391} 392 393static struct dma_chunk * dma_find_chunk(struct ps3_dma_region *r, 394 unsigned long bus_addr, unsigned long len) 395{ 396 struct dma_chunk *c; 397 unsigned long aligned_bus = _ALIGN_DOWN(bus_addr, 1 << r->page_size); 398 unsigned long aligned_len = _ALIGN_UP(len+bus_addr-aligned_bus, 399 1 << r->page_size); 400 401 list_for_each_entry(c, &r->chunk_list.head, link) { 402 /* intersection */ 403 if (aligned_bus >= c->bus_addr && 404 aligned_bus + aligned_len <= c->bus_addr + c->len) 405 return c; 406 407 /* below */ 408 if (aligned_bus + aligned_len <= c->bus_addr) 409 continue; 410 411 /* above */ 412 if (aligned_bus >= c->bus_addr + c->len) 413 continue; 414 415 /* we don't handle the multi-chunk case for now */ 416 dma_dump_chunk(c); 417 BUG(); 418 } 419 return NULL; 420} 421 422static struct dma_chunk *dma_find_chunk_lpar(struct ps3_dma_region *r, 423 unsigned long lpar_addr, unsigned long len) 424{ 425 struct dma_chunk *c; 426 unsigned long aligned_lpar = _ALIGN_DOWN(lpar_addr, 1 << r->page_size); 427 unsigned long aligned_len = _ALIGN_UP(len + lpar_addr - aligned_lpar, 428 1 << r->page_size); 429 430 list_for_each_entry(c, &r->chunk_list.head, link) { 431 /* intersection */ 432 if (c->lpar_addr <= aligned_lpar && 433 aligned_lpar < c->lpar_addr + c->len) { 434 if (aligned_lpar + aligned_len <= c->lpar_addr + c->len) 435 return c; 436 else { 437 dma_dump_chunk(c); 438 BUG(); 439 } 440 } 441 /* below */ 442 if (aligned_lpar + aligned_len <= c->lpar_addr) { 443 continue; 444 } 445 /* above */ 446 if (c->lpar_addr + c->len <= aligned_lpar) { 447 continue; 448 } 449 } 450 return NULL; 451} 452 453static int dma_sb_free_chunk(struct dma_chunk *c) 454{ 455 int result = 0; 456 457 if (c->bus_addr) { 458 result = lv1_unmap_device_dma_region(c->region->dev->bus_id, 459 c->region->dev->dev_id, c->bus_addr, c->len); 460 BUG_ON(result); 461 } 462 463 kfree(c); 464 return result; 465} 466 467static int dma_ioc0_free_chunk(struct dma_chunk *c) 468{ 469 int result = 0; 470 int iopage; 471 unsigned long offset; 472 struct ps3_dma_region *r = c->region; 473 474 DBG("%s:start\n", __func__); 475 for (iopage = 0; iopage < (c->len >> r->page_size); iopage++) { 476 offset = (1 << r->page_size) * iopage; 477 /* put INVALID entry */ 478 result = lv1_put_iopte(0, 479 c->bus_addr + offset, 480 c->lpar_addr + offset, 481 r->ioid, 482 0); 483 DBG("%s: bus=%#lx, lpar=%#lx, ioid=%d\n", __func__, 484 c->bus_addr + offset, 485 c->lpar_addr + offset, 486 r->ioid); 487 488 if (result) { 489 DBG("%s:%d: lv1_put_iopte failed: %s\n", __func__, 490 __LINE__, ps3_result(result)); 491 } 492 } 493 kfree(c); 494 DBG("%s:end\n", __func__); 495 return result; 496} 497 498/** 499 * dma_sb_map_pages - Maps dma pages into the io controller bus address space. 500 * @r: Pointer to a struct ps3_dma_region. 501 * @phys_addr: Starting physical address of the area to map. 502 * @len: Length in bytes of the area to map. 503 * c_out: A pointer to receive an allocated struct dma_chunk for this area. 504 * 505 * This is the lowest level dma mapping routine, and is the one that will 506 * make the HV call to add the pages into the io controller address space. 507 */ 508 509static int dma_sb_map_pages(struct ps3_dma_region *r, unsigned long phys_addr, 510 unsigned long len, struct dma_chunk **c_out, u64 iopte_flag) 511{ 512 int result; 513 struct dma_chunk *c; 514 515 c = kzalloc(sizeof(*c), GFP_ATOMIC); 516 if (!c) { 517 result = -ENOMEM; 518 goto fail_alloc; 519 } 520 521 c->region = r; 522 c->lpar_addr = ps3_mm_phys_to_lpar(phys_addr); 523 c->bus_addr = dma_sb_lpar_to_bus(r, c->lpar_addr); 524 c->len = len; 525 526 BUG_ON(iopte_flag != 0xf800000000000000UL); 527 result = lv1_map_device_dma_region(c->region->dev->bus_id, 528 c->region->dev->dev_id, c->lpar_addr, 529 c->bus_addr, c->len, iopte_flag); 530 if (result) { 531 DBG("%s:%d: lv1_map_device_dma_region failed: %s\n", 532 __func__, __LINE__, ps3_result(result)); 533 goto fail_map; 534 } 535 536 list_add(&c->link, &r->chunk_list.head); 537 538 *c_out = c; 539 return 0; 540 541fail_map: 542 kfree(c); 543fail_alloc: 544 *c_out = NULL; 545 DBG(" <- %s:%d\n", __func__, __LINE__); 546 return result; 547} 548 549static int dma_ioc0_map_pages(struct ps3_dma_region *r, unsigned long phys_addr, 550 unsigned long len, struct dma_chunk **c_out, 551 u64 iopte_flag) 552{ 553 int result; 554 struct dma_chunk *c, *last; 555 int iopage, pages; 556 unsigned long offset; 557 558 DBG(KERN_ERR "%s: phy=%#lx, lpar%#lx, len=%#lx\n", __func__, 559 phys_addr, ps3_mm_phys_to_lpar(phys_addr), len); 560 c = kzalloc(sizeof(*c), GFP_ATOMIC); 561 if (!c) { 562 result = -ENOMEM; 563 goto fail_alloc; 564 } 565 566 c->region = r; 567 c->len = len; 568 c->lpar_addr = ps3_mm_phys_to_lpar(phys_addr); 569 /* allocate IO address */ 570 if (list_empty(&r->chunk_list.head)) { 571 /* first one */ 572 c->bus_addr = r->bus_addr; 573 } else { 574 /* derive from last bus addr*/ 575 last = list_entry(r->chunk_list.head.next, 576 struct dma_chunk, link); 577 c->bus_addr = last->bus_addr + last->len; 578 DBG("%s: last bus=%#lx, len=%#lx\n", __func__, 579 last->bus_addr, last->len); 580 } 581 582 /* FIXME: check whether length exceeds region size */ 583 584 /* build ioptes for the area */ 585 pages = len >> r->page_size; 586 DBG("%s: pgsize=%#x len=%#lx pages=%#x iopteflag=%#llx\n", __func__, 587 r->page_size, r->len, pages, iopte_flag); 588 for (iopage = 0; iopage < pages; iopage++) { 589 offset = (1 << r->page_size) * iopage; 590 result = lv1_put_iopte(0, 591 c->bus_addr + offset, 592 c->lpar_addr + offset, 593 r->ioid, 594 iopte_flag); 595 if (result) { 596 pr_warn("%s:%d: lv1_put_iopte failed: %s\n", 597 __func__, __LINE__, ps3_result(result)); 598 goto fail_map; 599 } 600 DBG("%s: pg=%d bus=%#lx, lpar=%#lx, ioid=%#x\n", __func__, 601 iopage, c->bus_addr + offset, c->lpar_addr + offset, 602 r->ioid); 603 } 604 605 /* be sure that last allocated one is inserted at head */ 606 list_add(&c->link, &r->chunk_list.head); 607 608 *c_out = c; 609 DBG("%s: end\n", __func__); 610 return 0; 611 612fail_map: 613 for (iopage--; 0 <= iopage; iopage--) { 614 lv1_put_iopte(0, 615 c->bus_addr + offset, 616 c->lpar_addr + offset, 617 r->ioid, 618 0); 619 } 620 kfree(c); 621fail_alloc: 622 *c_out = NULL; 623 return result; 624} 625 626/** 627 * dma_sb_region_create - Create a device dma region. 628 * @r: Pointer to a struct ps3_dma_region. 629 * 630 * This is the lowest level dma region create routine, and is the one that 631 * will make the HV call to create the region. 632 */ 633 634static int dma_sb_region_create(struct ps3_dma_region *r) 635{ 636 int result; 637 u64 bus_addr; 638 639 DBG(" -> %s:%d:\n", __func__, __LINE__); 640 641 BUG_ON(!r); 642 643 if (!r->dev->bus_id) { 644 pr_info("%s:%d: %llu:%llu no dma\n", __func__, __LINE__, 645 r->dev->bus_id, r->dev->dev_id); 646 return 0; 647 } 648 649 DBG("%s:%u: len = 0x%lx, page_size = %u, offset = 0x%lx\n", __func__, 650 __LINE__, r->len, r->page_size, r->offset); 651 652 BUG_ON(!r->len); 653 BUG_ON(!r->page_size); 654 BUG_ON(!r->region_ops); 655 656 INIT_LIST_HEAD(&r->chunk_list.head); 657 spin_lock_init(&r->chunk_list.lock); 658 659 result = lv1_allocate_device_dma_region(r->dev->bus_id, r->dev->dev_id, 660 roundup_pow_of_two(r->len), r->page_size, r->region_type, 661 &bus_addr); 662 r->bus_addr = bus_addr; 663 664 if (result) { 665 DBG("%s:%d: lv1_allocate_device_dma_region failed: %s\n", 666 __func__, __LINE__, ps3_result(result)); 667 r->len = r->bus_addr = 0; 668 } 669 670 return result; 671} 672 673static int dma_ioc0_region_create(struct ps3_dma_region *r) 674{ 675 int result; 676 u64 bus_addr; 677 678 INIT_LIST_HEAD(&r->chunk_list.head); 679 spin_lock_init(&r->chunk_list.lock); 680 681 result = lv1_allocate_io_segment(0, 682 r->len, 683 r->page_size, 684 &bus_addr); 685 r->bus_addr = bus_addr; 686 if (result) { 687 DBG("%s:%d: lv1_allocate_io_segment failed: %s\n", 688 __func__, __LINE__, ps3_result(result)); 689 r->len = r->bus_addr = 0; 690 } 691 DBG("%s: len=%#lx, pg=%d, bus=%#lx\n", __func__, 692 r->len, r->page_size, r->bus_addr); 693 return result; 694} 695 696/** 697 * dma_region_free - Free a device dma region. 698 * @r: Pointer to a struct ps3_dma_region. 699 * 700 * This is the lowest level dma region free routine, and is the one that 701 * will make the HV call to free the region. 702 */ 703 704static int dma_sb_region_free(struct ps3_dma_region *r) 705{ 706 int result; 707 struct dma_chunk *c; 708 struct dma_chunk *tmp; 709 710 BUG_ON(!r); 711 712 if (!r->dev->bus_id) { 713 pr_info("%s:%d: %llu:%llu no dma\n", __func__, __LINE__, 714 r->dev->bus_id, r->dev->dev_id); 715 return 0; 716 } 717 718 list_for_each_entry_safe(c, tmp, &r->chunk_list.head, link) { 719 list_del(&c->link); 720 dma_sb_free_chunk(c); 721 } 722 723 result = lv1_free_device_dma_region(r->dev->bus_id, r->dev->dev_id, 724 r->bus_addr); 725 726 if (result) 727 DBG("%s:%d: lv1_free_device_dma_region failed: %s\n", 728 __func__, __LINE__, ps3_result(result)); 729 730 r->bus_addr = 0; 731 732 return result; 733} 734 735static int dma_ioc0_region_free(struct ps3_dma_region *r) 736{ 737 int result; 738 struct dma_chunk *c, *n; 739 740 DBG("%s: start\n", __func__); 741 list_for_each_entry_safe(c, n, &r->chunk_list.head, link) { 742 list_del(&c->link); 743 dma_ioc0_free_chunk(c); 744 } 745 746 result = lv1_release_io_segment(0, r->bus_addr); 747 748 if (result) 749 DBG("%s:%d: lv1_free_device_dma_region failed: %s\n", 750 __func__, __LINE__, ps3_result(result)); 751 752 r->bus_addr = 0; 753 DBG("%s: end\n", __func__); 754 755 return result; 756} 757 758/** 759 * dma_sb_map_area - Map an area of memory into a device dma region. 760 * @r: Pointer to a struct ps3_dma_region. 761 * @virt_addr: Starting virtual address of the area to map. 762 * @len: Length in bytes of the area to map. 763 * @bus_addr: A pointer to return the starting ioc bus address of the area to 764 * map. 765 * 766 * This is the common dma mapping routine. 767 */ 768 769static int dma_sb_map_area(struct ps3_dma_region *r, unsigned long virt_addr, 770 unsigned long len, dma_addr_t *bus_addr, 771 u64 iopte_flag) 772{ 773 int result; 774 unsigned long flags; 775 struct dma_chunk *c; 776 unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr) 777 : virt_addr; 778 unsigned long aligned_phys = _ALIGN_DOWN(phys_addr, 1 << r->page_size); 779 unsigned long aligned_len = _ALIGN_UP(len + phys_addr - aligned_phys, 780 1 << r->page_size); 781 *bus_addr = dma_sb_lpar_to_bus(r, ps3_mm_phys_to_lpar(phys_addr)); 782 783 if (!USE_DYNAMIC_DMA) { 784 unsigned long lpar_addr = ps3_mm_phys_to_lpar(phys_addr); 785 DBG(" -> %s:%d\n", __func__, __LINE__); 786 DBG("%s:%d virt_addr %lxh\n", __func__, __LINE__, 787 virt_addr); 788 DBG("%s:%d phys_addr %lxh\n", __func__, __LINE__, 789 phys_addr); 790 DBG("%s:%d lpar_addr %lxh\n", __func__, __LINE__, 791 lpar_addr); 792 DBG("%s:%d len %lxh\n", __func__, __LINE__, len); 793 DBG("%s:%d bus_addr %llxh (%lxh)\n", __func__, __LINE__, 794 *bus_addr, len); 795 } 796 797 spin_lock_irqsave(&r->chunk_list.lock, flags); 798 c = dma_find_chunk(r, *bus_addr, len); 799 800 if (c) { 801 DBG("%s:%d: reusing mapped chunk", __func__, __LINE__); 802 dma_dump_chunk(c); 803 c->usage_count++; 804 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 805 return 0; 806 } 807 808 result = dma_sb_map_pages(r, aligned_phys, aligned_len, &c, iopte_flag); 809 810 if (result) { 811 *bus_addr = 0; 812 DBG("%s:%d: dma_sb_map_pages failed (%d)\n", 813 __func__, __LINE__, result); 814 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 815 return result; 816 } 817 818 c->usage_count = 1; 819 820 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 821 return result; 822} 823 824static int dma_ioc0_map_area(struct ps3_dma_region *r, unsigned long virt_addr, 825 unsigned long len, dma_addr_t *bus_addr, 826 u64 iopte_flag) 827{ 828 int result; 829 unsigned long flags; 830 struct dma_chunk *c; 831 unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr) 832 : virt_addr; 833 unsigned long aligned_phys = _ALIGN_DOWN(phys_addr, 1 << r->page_size); 834 unsigned long aligned_len = _ALIGN_UP(len + phys_addr - aligned_phys, 835 1 << r->page_size); 836 837 DBG(KERN_ERR "%s: vaddr=%#lx, len=%#lx\n", __func__, 838 virt_addr, len); 839 DBG(KERN_ERR "%s: ph=%#lx a_ph=%#lx a_l=%#lx\n", __func__, 840 phys_addr, aligned_phys, aligned_len); 841 842 spin_lock_irqsave(&r->chunk_list.lock, flags); 843 c = dma_find_chunk_lpar(r, ps3_mm_phys_to_lpar(phys_addr), len); 844 845 if (c) { 846 /* FIXME */ 847 BUG(); 848 *bus_addr = c->bus_addr + phys_addr - aligned_phys; 849 c->usage_count++; 850 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 851 return 0; 852 } 853 854 result = dma_ioc0_map_pages(r, aligned_phys, aligned_len, &c, 855 iopte_flag); 856 857 if (result) { 858 *bus_addr = 0; 859 DBG("%s:%d: dma_ioc0_map_pages failed (%d)\n", 860 __func__, __LINE__, result); 861 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 862 return result; 863 } 864 *bus_addr = c->bus_addr + phys_addr - aligned_phys; 865 DBG("%s: va=%#lx pa=%#lx a_pa=%#lx bus=%#llx\n", __func__, 866 virt_addr, phys_addr, aligned_phys, *bus_addr); 867 c->usage_count = 1; 868 869 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 870 return result; 871} 872 873/** 874 * dma_sb_unmap_area - Unmap an area of memory from a device dma region. 875 * @r: Pointer to a struct ps3_dma_region. 876 * @bus_addr: The starting ioc bus address of the area to unmap. 877 * @len: Length in bytes of the area to unmap. 878 * 879 * This is the common dma unmap routine. 880 */ 881 882static int dma_sb_unmap_area(struct ps3_dma_region *r, dma_addr_t bus_addr, 883 unsigned long len) 884{ 885 unsigned long flags; 886 struct dma_chunk *c; 887 888 spin_lock_irqsave(&r->chunk_list.lock, flags); 889 c = dma_find_chunk(r, bus_addr, len); 890 891 if (!c) { 892 unsigned long aligned_bus = _ALIGN_DOWN(bus_addr, 893 1 << r->page_size); 894 unsigned long aligned_len = _ALIGN_UP(len + bus_addr 895 - aligned_bus, 1 << r->page_size); 896 DBG("%s:%d: not found: bus_addr %llxh\n", 897 __func__, __LINE__, bus_addr); 898 DBG("%s:%d: not found: len %lxh\n", 899 __func__, __LINE__, len); 900 DBG("%s:%d: not found: aligned_bus %lxh\n", 901 __func__, __LINE__, aligned_bus); 902 DBG("%s:%d: not found: aligned_len %lxh\n", 903 __func__, __LINE__, aligned_len); 904 BUG(); 905 } 906 907 c->usage_count--; 908 909 if (!c->usage_count) { 910 list_del(&c->link); 911 dma_sb_free_chunk(c); 912 } 913 914 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 915 return 0; 916} 917 918static int dma_ioc0_unmap_area(struct ps3_dma_region *r, 919 dma_addr_t bus_addr, unsigned long len) 920{ 921 unsigned long flags; 922 struct dma_chunk *c; 923 924 DBG("%s: start a=%#llx l=%#lx\n", __func__, bus_addr, len); 925 spin_lock_irqsave(&r->chunk_list.lock, flags); 926 c = dma_find_chunk(r, bus_addr, len); 927 928 if (!c) { 929 unsigned long aligned_bus = _ALIGN_DOWN(bus_addr, 930 1 << r->page_size); 931 unsigned long aligned_len = _ALIGN_UP(len + bus_addr 932 - aligned_bus, 933 1 << r->page_size); 934 DBG("%s:%d: not found: bus_addr %llxh\n", 935 __func__, __LINE__, bus_addr); 936 DBG("%s:%d: not found: len %lxh\n", 937 __func__, __LINE__, len); 938 DBG("%s:%d: not found: aligned_bus %lxh\n", 939 __func__, __LINE__, aligned_bus); 940 DBG("%s:%d: not found: aligned_len %lxh\n", 941 __func__, __LINE__, aligned_len); 942 BUG(); 943 } 944 945 c->usage_count--; 946 947 if (!c->usage_count) { 948 list_del(&c->link); 949 dma_ioc0_free_chunk(c); 950 } 951 952 spin_unlock_irqrestore(&r->chunk_list.lock, flags); 953 DBG("%s: end\n", __func__); 954 return 0; 955} 956 957/** 958 * dma_sb_region_create_linear - Setup a linear dma mapping for a device. 959 * @r: Pointer to a struct ps3_dma_region. 960 * 961 * This routine creates an HV dma region for the device and maps all available 962 * ram into the io controller bus address space. 963 */ 964 965static int dma_sb_region_create_linear(struct ps3_dma_region *r) 966{ 967 int result; 968 unsigned long virt_addr, len; 969 dma_addr_t tmp; 970 971 if (r->len > 16*1024*1024) { /* FIXME: need proper fix */ 972 /* force 16M dma pages for linear mapping */ 973 if (r->page_size != PS3_DMA_16M) { 974 pr_info("%s:%d: forcing 16M pages for linear map\n", 975 __func__, __LINE__); 976 r->page_size = PS3_DMA_16M; 977 r->len = _ALIGN_UP(r->len, 1 << r->page_size); 978 } 979 } 980 981 result = dma_sb_region_create(r); 982 BUG_ON(result); 983 984 if (r->offset < map.rm.size) { 985 /* Map (part of) 1st RAM chunk */ 986 virt_addr = map.rm.base + r->offset; 987 len = map.rm.size - r->offset; 988 if (len > r->len) 989 len = r->len; 990 result = dma_sb_map_area(r, virt_addr, len, &tmp, 991 CBE_IOPTE_PP_W | CBE_IOPTE_PP_R | CBE_IOPTE_SO_RW | 992 CBE_IOPTE_M); 993 BUG_ON(result); 994 } 995 996 if (r->offset + r->len > map.rm.size) { 997 /* Map (part of) 2nd RAM chunk */ 998 virt_addr = map.rm.size; 999 len = r->len; 1000 if (r->offset >= map.rm.size) 1001 virt_addr += r->offset - map.rm.size; 1002 else 1003 len -= map.rm.size - r->offset; 1004 result = dma_sb_map_area(r, virt_addr, len, &tmp, 1005 CBE_IOPTE_PP_W | CBE_IOPTE_PP_R | CBE_IOPTE_SO_RW | 1006 CBE_IOPTE_M); 1007 BUG_ON(result); 1008 } 1009 1010 return result; 1011} 1012 1013/** 1014 * dma_sb_region_free_linear - Free a linear dma mapping for a device. 1015 * @r: Pointer to a struct ps3_dma_region. 1016 * 1017 * This routine will unmap all mapped areas and free the HV dma region. 1018 */ 1019 1020static int dma_sb_region_free_linear(struct ps3_dma_region *r) 1021{ 1022 int result; 1023 dma_addr_t bus_addr; 1024 unsigned long len, lpar_addr; 1025 1026 if (r->offset < map.rm.size) { 1027 /* Unmap (part of) 1st RAM chunk */ 1028 lpar_addr = map.rm.base + r->offset; 1029 len = map.rm.size - r->offset; 1030 if (len > r->len) 1031 len = r->len; 1032 bus_addr = dma_sb_lpar_to_bus(r, lpar_addr); 1033 result = dma_sb_unmap_area(r, bus_addr, len); 1034 BUG_ON(result); 1035 } 1036 1037 if (r->offset + r->len > map.rm.size) { 1038 /* Unmap (part of) 2nd RAM chunk */ 1039 lpar_addr = map.r1.base; 1040 len = r->len; 1041 if (r->offset >= map.rm.size) 1042 lpar_addr += r->offset - map.rm.size; 1043 else 1044 len -= map.rm.size - r->offset; 1045 bus_addr = dma_sb_lpar_to_bus(r, lpar_addr); 1046 result = dma_sb_unmap_area(r, bus_addr, len); 1047 BUG_ON(result); 1048 } 1049 1050 result = dma_sb_region_free(r); 1051 BUG_ON(result); 1052 1053 return result; 1054} 1055 1056/** 1057 * dma_sb_map_area_linear - Map an area of memory into a device dma region. 1058 * @r: Pointer to a struct ps3_dma_region. 1059 * @virt_addr: Starting virtual address of the area to map. 1060 * @len: Length in bytes of the area to map. 1061 * @bus_addr: A pointer to return the starting ioc bus address of the area to 1062 * map. 1063 * 1064 * This routine just returns the corresponding bus address. Actual mapping 1065 * occurs in dma_region_create_linear(). 1066 */ 1067 1068static int dma_sb_map_area_linear(struct ps3_dma_region *r, 1069 unsigned long virt_addr, unsigned long len, dma_addr_t *bus_addr, 1070 u64 iopte_flag) 1071{ 1072 unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr) 1073 : virt_addr; 1074 *bus_addr = dma_sb_lpar_to_bus(r, ps3_mm_phys_to_lpar(phys_addr)); 1075 return 0; 1076} 1077 1078/** 1079 * dma_unmap_area_linear - Unmap an area of memory from a device dma region. 1080 * @r: Pointer to a struct ps3_dma_region. 1081 * @bus_addr: The starting ioc bus address of the area to unmap. 1082 * @len: Length in bytes of the area to unmap. 1083 * 1084 * This routine does nothing. Unmapping occurs in dma_sb_region_free_linear(). 1085 */ 1086 1087static int dma_sb_unmap_area_linear(struct ps3_dma_region *r, 1088 dma_addr_t bus_addr, unsigned long len) 1089{ 1090 return 0; 1091}; 1092 1093static const struct ps3_dma_region_ops ps3_dma_sb_region_ops = { 1094 .create = dma_sb_region_create, 1095 .free = dma_sb_region_free, 1096 .map = dma_sb_map_area, 1097 .unmap = dma_sb_unmap_area 1098}; 1099 1100static const struct ps3_dma_region_ops ps3_dma_sb_region_linear_ops = { 1101 .create = dma_sb_region_create_linear, 1102 .free = dma_sb_region_free_linear, 1103 .map = dma_sb_map_area_linear, 1104 .unmap = dma_sb_unmap_area_linear 1105}; 1106 1107static const struct ps3_dma_region_ops ps3_dma_ioc0_region_ops = { 1108 .create = dma_ioc0_region_create, 1109 .free = dma_ioc0_region_free, 1110 .map = dma_ioc0_map_area, 1111 .unmap = dma_ioc0_unmap_area 1112}; 1113 1114int ps3_dma_region_init(struct ps3_system_bus_device *dev, 1115 struct ps3_dma_region *r, enum ps3_dma_page_size page_size, 1116 enum ps3_dma_region_type region_type, void *addr, unsigned long len) 1117{ 1118 unsigned long lpar_addr; 1119 1120 lpar_addr = addr ? ps3_mm_phys_to_lpar(__pa(addr)) : 0; 1121 1122 r->dev = dev; 1123 r->page_size = page_size; 1124 r->region_type = region_type; 1125 r->offset = lpar_addr; 1126 if (r->offset >= map.rm.size) 1127 r->offset -= map.r1.offset; 1128 r->len = len ? len : _ALIGN_UP(map.total, 1 << r->page_size); 1129 1130 switch (dev->dev_type) { 1131 case PS3_DEVICE_TYPE_SB: 1132 r->region_ops = (USE_DYNAMIC_DMA) 1133 ? &ps3_dma_sb_region_ops 1134 : &ps3_dma_sb_region_linear_ops; 1135 break; 1136 case PS3_DEVICE_TYPE_IOC0: 1137 r->region_ops = &ps3_dma_ioc0_region_ops; 1138 break; 1139 default: 1140 BUG(); 1141 return -EINVAL; 1142 } 1143 return 0; 1144} 1145EXPORT_SYMBOL(ps3_dma_region_init); 1146 1147int ps3_dma_region_create(struct ps3_dma_region *r) 1148{ 1149 BUG_ON(!r); 1150 BUG_ON(!r->region_ops); 1151 BUG_ON(!r->region_ops->create); 1152 return r->region_ops->create(r); 1153} 1154EXPORT_SYMBOL(ps3_dma_region_create); 1155 1156int ps3_dma_region_free(struct ps3_dma_region *r) 1157{ 1158 BUG_ON(!r); 1159 BUG_ON(!r->region_ops); 1160 BUG_ON(!r->region_ops->free); 1161 return r->region_ops->free(r); 1162} 1163EXPORT_SYMBOL(ps3_dma_region_free); 1164 1165int ps3_dma_map(struct ps3_dma_region *r, unsigned long virt_addr, 1166 unsigned long len, dma_addr_t *bus_addr, 1167 u64 iopte_flag) 1168{ 1169 return r->region_ops->map(r, virt_addr, len, bus_addr, iopte_flag); 1170} 1171 1172int ps3_dma_unmap(struct ps3_dma_region *r, dma_addr_t bus_addr, 1173 unsigned long len) 1174{ 1175 return r->region_ops->unmap(r, bus_addr, len); 1176} 1177 1178/*============================================================================*/ 1179/* system startup routines */ 1180/*============================================================================*/ 1181 1182/** 1183 * ps3_mm_init - initialize the address space state variables 1184 */ 1185 1186void __init ps3_mm_init(void) 1187{ 1188 int result; 1189 1190 DBG(" -> %s:%d\n", __func__, __LINE__); 1191 1192 result = ps3_repository_read_mm_info(&map.rm.base, &map.rm.size, 1193 &map.total); 1194 1195 if (result) 1196 panic("ps3_repository_read_mm_info() failed"); 1197 1198 map.rm.offset = map.rm.base; 1199 map.vas_id = map.htab_size = 0; 1200 1201 /* this implementation assumes map.rm.base is zero */ 1202 1203 BUG_ON(map.rm.base); 1204 BUG_ON(!map.rm.size); 1205 1206 /* Check if we got the highmem region from an earlier boot step */ 1207 1208 if (ps3_mm_get_repository_highmem(&map.r1)) { 1209 result = ps3_mm_region_create(&map.r1, map.total - map.rm.size); 1210 1211 if (!result) 1212 ps3_mm_set_repository_highmem(&map.r1); 1213 } 1214 1215 /* correct map.total for the real total amount of memory we use */ 1216 map.total = map.rm.size + map.r1.size; 1217 1218 if (!map.r1.size) { 1219 DBG("%s:%d: No highmem region found\n", __func__, __LINE__); 1220 } else { 1221 DBG("%s:%d: Adding highmem region: %llxh %llxh\n", 1222 __func__, __LINE__, map.rm.size, 1223 map.total - map.rm.size); 1224 memblock_add(map.rm.size, map.total - map.rm.size); 1225 } 1226 1227 DBG(" <- %s:%d\n", __func__, __LINE__); 1228} 1229 1230/** 1231 * ps3_mm_shutdown - final cleanup of address space 1232 */ 1233 1234void ps3_mm_shutdown(void) 1235{ 1236 ps3_mm_region_destroy(&map.r1); 1237}