arch/powerpc/platforms/ps3/mm.c

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