Pull video into test branch
[linux-2.6] / 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/ps3.h>
29 #include <asm/lv1call.h>
30
31 #include "platform.h"
32
33 #if defined(DEBUG)
34 #define DBG(fmt...) udbg_printf(fmt)
35 #else
36 #define DBG(fmt...) do{if(0)printk(fmt);}while(0)
37 #endif
38
39 enum {
40 #if defined(CONFIG_PS3_USE_LPAR_ADDR)
41         USE_LPAR_ADDR = 1,
42 #else
43         USE_LPAR_ADDR = 0,
44 #endif
45 #if defined(CONFIG_PS3_DYNAMIC_DMA)
46         USE_DYNAMIC_DMA = 1,
47 #else
48         USE_DYNAMIC_DMA = 0,
49 #endif
50 };
51
52 enum {
53         PAGE_SHIFT_4K = 12U,
54         PAGE_SHIFT_64K = 16U,
55         PAGE_SHIFT_16M = 24U,
56 };
57
58 static unsigned long make_page_sizes(unsigned long a, unsigned long b)
59 {
60         return (a << 56) | (b << 48);
61 }
62
63 enum {
64         ALLOCATE_MEMORY_TRY_ALT_UNIT = 0X04,
65         ALLOCATE_MEMORY_ADDR_ZERO = 0X08,
66 };
67
68 /* valid htab sizes are {18,19,20} = 256K, 512K, 1M */
69
70 enum {
71         HTAB_SIZE_MAX = 20U, /* HV limit of 1MB */
72         HTAB_SIZE_MIN = 18U, /* CPU limit of 256KB */
73 };
74
75 /*============================================================================*/
76 /* virtual address space routines                                             */
77 /*============================================================================*/
78
79 /**
80  * struct mem_region - memory region structure
81  * @base: base address
82  * @size: size in bytes
83  * @offset: difference between base and rm.size
84  */
85
86 struct mem_region {
87         unsigned long base;
88         unsigned long size;
89         unsigned long offset;
90 };
91
92 /**
93  * struct map - address space state variables holder
94  * @total: total memory available as reported by HV
95  * @vas_id - HV virtual address space id
96  * @htab_size: htab size in bytes
97  *
98  * The HV virtual address space (vas) allows for hotplug memory regions.
99  * Memory regions can be created and destroyed in the vas at runtime.
100  * @rm: real mode (bootmem) region
101  * @r1: hotplug memory region(s)
102  *
103  * ps3 addresses
104  * virt_addr: a cpu 'translated' effective address
105  * phys_addr: an address in what Linux thinks is the physical address space
106  * lpar_addr: an address in the HV virtual address space
107  * bus_addr: an io controller 'translated' address on a device bus
108  */
109
110 struct map {
111         unsigned long total;
112         unsigned long vas_id;
113         unsigned long htab_size;
114         struct mem_region rm;
115         struct mem_region r1;
116 };
117
118 #define debug_dump_map(x) _debug_dump_map(x, __func__, __LINE__)
119 static void _debug_dump_map(const struct map* m, const char* func, int line)
120 {
121         DBG("%s:%d: map.total     = %lxh\n", func, line, m->total);
122         DBG("%s:%d: map.rm.size   = %lxh\n", func, line, m->rm.size);
123         DBG("%s:%d: map.vas_id    = %lu\n", func, line, m->vas_id);
124         DBG("%s:%d: map.htab_size = %lxh\n", func, line, m->htab_size);
125         DBG("%s:%d: map.r1.base   = %lxh\n", func, line, m->r1.base);
126         DBG("%s:%d: map.r1.offset = %lxh\n", func, line, m->r1.offset);
127         DBG("%s:%d: map.r1.size   = %lxh\n", func, line, m->r1.size);
128 }
129
130 static struct map map;
131
132 /**
133  * ps3_mm_phys_to_lpar - translate a linux physical address to lpar address
134  * @phys_addr: linux physical address
135  */
136
137 unsigned long ps3_mm_phys_to_lpar(unsigned long phys_addr)
138 {
139         BUG_ON(is_kernel_addr(phys_addr));
140         if (USE_LPAR_ADDR)
141                 return phys_addr;
142         else
143                 return (phys_addr < map.rm.size || phys_addr >= map.total)
144                         ? phys_addr : phys_addr + map.r1.offset;
145 }
146
147 EXPORT_SYMBOL(ps3_mm_phys_to_lpar);
148
149 /**
150  * ps3_mm_vas_create - create the virtual address space
151  */
152
153 void __init ps3_mm_vas_create(unsigned long* htab_size)
154 {
155         int result;
156         unsigned long start_address;
157         unsigned long size;
158         unsigned long access_right;
159         unsigned long max_page_size;
160         unsigned long flags;
161
162         result = lv1_query_logical_partition_address_region_info(0,
163                 &start_address, &size, &access_right, &max_page_size,
164                 &flags);
165
166         if (result) {
167                 DBG("%s:%d: lv1_query_logical_partition_address_region_info "
168                         "failed: %s\n", __func__, __LINE__,
169                         ps3_result(result));
170                 goto fail;
171         }
172
173         if (max_page_size < PAGE_SHIFT_16M) {
174                 DBG("%s:%d: bad max_page_size %lxh\n", __func__, __LINE__,
175                         max_page_size);
176                 goto fail;
177         }
178
179         BUILD_BUG_ON(CONFIG_PS3_HTAB_SIZE > HTAB_SIZE_MAX);
180         BUILD_BUG_ON(CONFIG_PS3_HTAB_SIZE < HTAB_SIZE_MIN);
181
182         result = lv1_construct_virtual_address_space(CONFIG_PS3_HTAB_SIZE,
183                         2, make_page_sizes(PAGE_SHIFT_16M, PAGE_SHIFT_64K),
184                         &map.vas_id, &map.htab_size);
185
186         if (result) {
187                 DBG("%s:%d: lv1_construct_virtual_address_space failed: %s\n",
188                         __func__, __LINE__, ps3_result(result));
189                 goto fail;
190         }
191
192         result = lv1_select_virtual_address_space(map.vas_id);
193
194         if (result) {
195                 DBG("%s:%d: lv1_select_virtual_address_space failed: %s\n",
196                         __func__, __LINE__, ps3_result(result));
197                 goto fail;
198         }
199
200         *htab_size = map.htab_size;
201
202         debug_dump_map(&map);
203
204         return;
205
206 fail:
207         panic("ps3_mm_vas_create failed");
208 }
209
210 /**
211  * ps3_mm_vas_destroy -
212  */
213
214 void ps3_mm_vas_destroy(void)
215 {
216         if (map.vas_id) {
217                 lv1_select_virtual_address_space(0);
218                 lv1_destruct_virtual_address_space(map.vas_id);
219                 map.vas_id = 0;
220         }
221 }
222
223 /*============================================================================*/
224 /* memory hotplug routines                                                    */
225 /*============================================================================*/
226
227 /**
228  * ps3_mm_region_create - create a memory region in the vas
229  * @r: pointer to a struct mem_region to accept initialized values
230  * @size: requested region size
231  *
232  * This implementation creates the region with the vas large page size.
233  * @size is rounded down to a multiple of the vas large page size.
234  */
235
236 int ps3_mm_region_create(struct mem_region *r, unsigned long size)
237 {
238         int result;
239         unsigned long muid;
240
241         r->size = _ALIGN_DOWN(size, 1 << PAGE_SHIFT_16M);
242
243         DBG("%s:%d requested  %lxh\n", __func__, __LINE__, size);
244         DBG("%s:%d actual     %lxh\n", __func__, __LINE__, r->size);
245         DBG("%s:%d difference %lxh (%luMB)\n", __func__, __LINE__,
246                 (unsigned long)(size - r->size),
247                 (size - r->size) / 1024 / 1024);
248
249         if (r->size == 0) {
250                 DBG("%s:%d: size == 0\n", __func__, __LINE__);
251                 result = -1;
252                 goto zero_region;
253         }
254
255         result = lv1_allocate_memory(r->size, PAGE_SHIFT_16M, 0,
256                 ALLOCATE_MEMORY_TRY_ALT_UNIT, &r->base, &muid);
257
258         if (result || r->base < map.rm.size) {
259                 DBG("%s:%d: lv1_allocate_memory failed: %s\n",
260                         __func__, __LINE__, ps3_result(result));
261                 goto zero_region;
262         }
263
264         r->offset = r->base - map.rm.size;
265         return result;
266
267 zero_region:
268         r->size = r->base = r->offset = 0;
269         return result;
270 }
271
272 /**
273  * ps3_mm_region_destroy - destroy a memory region
274  * @r: pointer to struct mem_region
275  */
276
277 void ps3_mm_region_destroy(struct mem_region *r)
278 {
279         if (r->base) {
280                 lv1_release_memory(r->base);
281                 r->size = r->base = r->offset = 0;
282                 map.total = map.rm.size;
283         }
284 }
285
286 /**
287  * ps3_mm_add_memory - hot add memory
288  */
289
290 static int __init ps3_mm_add_memory(void)
291 {
292         int result;
293         unsigned long start_addr;
294         unsigned long start_pfn;
295         unsigned long nr_pages;
296
297         if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
298                 return 0;
299
300         BUG_ON(!mem_init_done);
301
302         start_addr = USE_LPAR_ADDR ? map.r1.base : map.rm.size;
303         start_pfn = start_addr >> PAGE_SHIFT;
304         nr_pages = (map.r1.size + PAGE_SIZE - 1) >> PAGE_SHIFT;
305
306         DBG("%s:%d: start_addr %lxh, start_pfn %lxh, nr_pages %lxh\n",
307                 __func__, __LINE__, start_addr, start_pfn, nr_pages);
308
309         result = add_memory(0, start_addr, map.r1.size);
310
311         if (result) {
312                 DBG("%s:%d: add_memory failed: (%d)\n",
313                         __func__, __LINE__, result);
314                 return result;
315         }
316
317         result = online_pages(start_pfn, nr_pages);
318
319         if (result)
320                 DBG("%s:%d: online_pages failed: (%d)\n",
321                         __func__, __LINE__, result);
322
323         return result;
324 }
325
326 core_initcall(ps3_mm_add_memory);
327
328 /*============================================================================*/
329 /* dma routines                                                               */
330 /*============================================================================*/
331
332 /**
333  * dma_lpar_to_bus - Translate an lpar address to ioc mapped bus address.
334  * @r: pointer to dma region structure
335  * @lpar_addr: HV lpar address
336  */
337
338 static unsigned long dma_lpar_to_bus(struct ps3_dma_region *r,
339         unsigned long lpar_addr)
340 {
341         BUG_ON(lpar_addr >= map.r1.base + map.r1.size);
342         return r->bus_addr + (lpar_addr <= map.rm.size ? lpar_addr
343                 : lpar_addr - map.r1.offset);
344 }
345
346 #define dma_dump_region(_a) _dma_dump_region(_a, __func__, __LINE__)
347 static void _dma_dump_region(const struct ps3_dma_region *r, const char* func,
348         int line)
349 {
350         DBG("%s:%d: dev        %u:%u\n", func, line, r->did.bus_id,
351                 r->did.dev_id);
352         DBG("%s:%d: page_size  %u\n", func, line, r->page_size);
353         DBG("%s:%d: bus_addr   %lxh\n", func, line, r->bus_addr);
354         DBG("%s:%d: len        %lxh\n", func, line, r->len);
355 }
356
357 /**
358  * dma_chunk - A chunk of dma pages mapped by the io controller.
359  * @region - The dma region that owns this chunk.
360  * @lpar_addr: Starting lpar address of the area to map.
361  * @bus_addr: Starting ioc bus address of the area to map.
362  * @len: Length in bytes of the area to map.
363  * @link: A struct list_head used with struct ps3_dma_region.chunk_list, the
364  * list of all chuncks owned by the region.
365  *
366  * This implementation uses a very simple dma page manager
367  * based on the dma_chunk structure.  This scheme assumes
368  * that all drivers use very well behaved dma ops.
369  */
370
371 struct dma_chunk {
372         struct ps3_dma_region *region;
373         unsigned long lpar_addr;
374         unsigned long bus_addr;
375         unsigned long len;
376         struct list_head link;
377         unsigned int usage_count;
378 };
379
380 #define dma_dump_chunk(_a) _dma_dump_chunk(_a, __func__, __LINE__)
381 static void _dma_dump_chunk (const struct dma_chunk* c, const char* func,
382         int line)
383 {
384         DBG("%s:%d: r.dev        %u:%u\n", func, line,
385                 c->region->did.bus_id, c->region->did.dev_id);
386         DBG("%s:%d: r.bus_addr   %lxh\n", func, line, c->region->bus_addr);
387         DBG("%s:%d: r.page_size  %u\n", func, line, c->region->page_size);
388         DBG("%s:%d: r.len        %lxh\n", func, line, c->region->len);
389         DBG("%s:%d: c.lpar_addr  %lxh\n", func, line, c->lpar_addr);
390         DBG("%s:%d: c.bus_addr   %lxh\n", func, line, c->bus_addr);
391         DBG("%s:%d: c.len        %lxh\n", func, line, c->len);
392 }
393
394 static struct dma_chunk * dma_find_chunk(struct ps3_dma_region *r,
395         unsigned long bus_addr, unsigned long len)
396 {
397         struct dma_chunk *c;
398         unsigned long aligned_bus = _ALIGN_DOWN(bus_addr, 1 << r->page_size);
399         unsigned long aligned_len = _ALIGN_UP(len, 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 < c->bus_addr + c->len
405                         && aligned_bus + aligned_len <= c->bus_addr + c->len) {
406                         return c;
407                 }
408                 /* below */
409                 if (aligned_bus + aligned_len <= c->bus_addr) {
410                         continue;
411                 }
412                 /* above */
413                 if (aligned_bus >= c->bus_addr + c->len) {
414                         continue;
415                 }
416
417                 /* we don't handle the multi-chunk case for now */
418
419                 dma_dump_chunk(c);
420                 BUG();
421         }
422         return NULL;
423 }
424
425 static int dma_free_chunk(struct dma_chunk *c)
426 {
427         int result = 0;
428
429         if (c->bus_addr) {
430                 result = lv1_unmap_device_dma_region(c->region->did.bus_id,
431                         c->region->did.dev_id, c->bus_addr, c->len);
432                 BUG_ON(result);
433         }
434
435         kfree(c);
436         return result;
437 }
438
439 /**
440  * dma_map_pages - Maps dma pages into the io controller bus address space.
441  * @r: Pointer to a struct ps3_dma_region.
442  * @phys_addr: Starting physical address of the area to map.
443  * @len: Length in bytes of the area to map.
444  * c_out: A pointer to receive an allocated struct dma_chunk for this area.
445  *
446  * This is the lowest level dma mapping routine, and is the one that will
447  * make the HV call to add the pages into the io controller address space.
448  */
449
450 static int dma_map_pages(struct ps3_dma_region *r, unsigned long phys_addr,
451         unsigned long len, struct dma_chunk **c_out)
452 {
453         int result;
454         struct dma_chunk *c;
455
456         c = kzalloc(sizeof(struct dma_chunk), GFP_ATOMIC);
457
458         if (!c) {
459                 result = -ENOMEM;
460                 goto fail_alloc;
461         }
462
463         c->region = r;
464         c->lpar_addr = ps3_mm_phys_to_lpar(phys_addr);
465         c->bus_addr = dma_lpar_to_bus(r, c->lpar_addr);
466         c->len = len;
467
468         result = lv1_map_device_dma_region(c->region->did.bus_id,
469                 c->region->did.dev_id, c->lpar_addr, c->bus_addr, c->len,
470                 0xf800000000000000UL);
471
472         if (result) {
473                 DBG("%s:%d: lv1_map_device_dma_region failed: %s\n",
474                         __func__, __LINE__, ps3_result(result));
475                 goto fail_map;
476         }
477
478         list_add(&c->link, &r->chunk_list.head);
479
480         *c_out = c;
481         return 0;
482
483 fail_map:
484         kfree(c);
485 fail_alloc:
486         *c_out = NULL;
487         DBG(" <- %s:%d\n", __func__, __LINE__);
488         return result;
489 }
490
491 /**
492  * dma_region_create - Create a device dma region.
493  * @r: Pointer to a struct ps3_dma_region.
494  *
495  * This is the lowest level dma region create routine, and is the one that
496  * will make the HV call to create the region.
497  */
498
499 static int dma_region_create(struct ps3_dma_region* r)
500 {
501         int result;
502
503         r->len = _ALIGN_UP(map.total, 1 << r->page_size);
504         INIT_LIST_HEAD(&r->chunk_list.head);
505         spin_lock_init(&r->chunk_list.lock);
506
507         result = lv1_allocate_device_dma_region(r->did.bus_id, r->did.dev_id,
508                 r->len, r->page_size, r->region_type, &r->bus_addr);
509
510         dma_dump_region(r);
511
512         if (result) {
513                 DBG("%s:%d: lv1_allocate_device_dma_region failed: %s\n",
514                         __func__, __LINE__, ps3_result(result));
515                 r->len = r->bus_addr = 0;
516         }
517
518         return result;
519 }
520
521 /**
522  * dma_region_free - Free a device dma region.
523  * @r: Pointer to a struct ps3_dma_region.
524  *
525  * This is the lowest level dma region free routine, and is the one that
526  * will make the HV call to free the region.
527  */
528
529 static int dma_region_free(struct ps3_dma_region* r)
530 {
531         int result;
532         struct dma_chunk *c;
533         struct dma_chunk *tmp;
534
535         list_for_each_entry_safe(c, tmp, &r->chunk_list.head, link) {
536                 list_del(&c->link);
537                 dma_free_chunk(c);
538         }
539
540         result = lv1_free_device_dma_region(r->did.bus_id, r->did.dev_id,
541                 r->bus_addr);
542
543         if (result)
544                 DBG("%s:%d: lv1_free_device_dma_region failed: %s\n",
545                         __func__, __LINE__, ps3_result(result));
546
547         r->len = r->bus_addr = 0;
548
549         return result;
550 }
551
552 /**
553  * dma_map_area - Map an area of memory into a device dma region.
554  * @r: Pointer to a struct ps3_dma_region.
555  * @virt_addr: Starting virtual address of the area to map.
556  * @len: Length in bytes of the area to map.
557  * @bus_addr: A pointer to return the starting ioc bus address of the area to
558  * map.
559  *
560  * This is the common dma mapping routine.
561  */
562
563 static int dma_map_area(struct ps3_dma_region *r, unsigned long virt_addr,
564         unsigned long len, unsigned long *bus_addr)
565 {
566         int result;
567         unsigned long flags;
568         struct dma_chunk *c;
569         unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr)
570                 : virt_addr;
571
572         *bus_addr = dma_lpar_to_bus(r, ps3_mm_phys_to_lpar(phys_addr));
573
574         if (!USE_DYNAMIC_DMA) {
575                 unsigned long lpar_addr = ps3_mm_phys_to_lpar(phys_addr);
576                 DBG(" -> %s:%d\n", __func__, __LINE__);
577                 DBG("%s:%d virt_addr %lxh\n", __func__, __LINE__,
578                         virt_addr);
579                 DBG("%s:%d phys_addr %lxh\n", __func__, __LINE__,
580                         phys_addr);
581                 DBG("%s:%d lpar_addr %lxh\n", __func__, __LINE__,
582                         lpar_addr);
583                 DBG("%s:%d len       %lxh\n", __func__, __LINE__, len);
584                 DBG("%s:%d bus_addr  %lxh (%lxh)\n", __func__, __LINE__,
585                 *bus_addr, len);
586         }
587
588         spin_lock_irqsave(&r->chunk_list.lock, flags);
589         c = dma_find_chunk(r, *bus_addr, len);
590
591         if (c) {
592                 c->usage_count++;
593                 spin_unlock_irqrestore(&r->chunk_list.lock, flags);
594                 return 0;
595         }
596
597         result = dma_map_pages(r, _ALIGN_DOWN(phys_addr, 1 << r->page_size),
598                 _ALIGN_UP(len, 1 << r->page_size), &c);
599
600         if (result) {
601                 *bus_addr = 0;
602                 DBG("%s:%d: dma_map_pages failed (%d)\n",
603                         __func__, __LINE__, result);
604                 spin_unlock_irqrestore(&r->chunk_list.lock, flags);
605                 return result;
606         }
607
608         c->usage_count = 1;
609
610         spin_unlock_irqrestore(&r->chunk_list.lock, flags);
611         return result;
612 }
613
614 /**
615  * dma_unmap_area - Unmap an area of memory from a device dma region.
616  * @r: Pointer to a struct ps3_dma_region.
617  * @bus_addr: The starting ioc bus address of the area to unmap.
618  * @len: Length in bytes of the area to unmap.
619  *
620  * This is the common dma unmap routine.
621  */
622
623 int dma_unmap_area(struct ps3_dma_region *r, unsigned long bus_addr,
624         unsigned long len)
625 {
626         unsigned long flags;
627         struct dma_chunk *c;
628
629         spin_lock_irqsave(&r->chunk_list.lock, flags);
630         c = dma_find_chunk(r, bus_addr, len);
631
632         if (!c) {
633                 unsigned long aligned_bus = _ALIGN_DOWN(bus_addr,
634                         1 << r->page_size);
635                 unsigned long aligned_len = _ALIGN_UP(len, 1 << r->page_size);
636                 DBG("%s:%d: not found: bus_addr %lxh\n",
637                         __func__, __LINE__, bus_addr);
638                 DBG("%s:%d: not found: len %lxh\n",
639                         __func__, __LINE__, len);
640                 DBG("%s:%d: not found: aligned_bus %lxh\n",
641                         __func__, __LINE__, aligned_bus);
642                 DBG("%s:%d: not found: aligned_len %lxh\n",
643                         __func__, __LINE__, aligned_len);
644                 BUG();
645         }
646
647         c->usage_count--;
648
649         if (!c->usage_count) {
650                 list_del(&c->link);
651                 dma_free_chunk(c);
652         }
653
654         spin_unlock_irqrestore(&r->chunk_list.lock, flags);
655         return 0;
656 }
657
658 /**
659  * dma_region_create_linear - Setup a linear dma maping for a device.
660  * @r: Pointer to a struct ps3_dma_region.
661  *
662  * This routine creates an HV dma region for the device and maps all available
663  * ram into the io controller bus address space.
664  */
665
666 static int dma_region_create_linear(struct ps3_dma_region *r)
667 {
668         int result;
669         unsigned long tmp;
670
671         /* force 16M dma pages for linear mapping */
672
673         if (r->page_size != PS3_DMA_16M) {
674                 pr_info("%s:%d: forcing 16M pages for linear map\n",
675                         __func__, __LINE__);
676                 r->page_size = PS3_DMA_16M;
677         }
678
679         result = dma_region_create(r);
680         BUG_ON(result);
681
682         result = dma_map_area(r, map.rm.base, map.rm.size, &tmp);
683         BUG_ON(result);
684
685         if (USE_LPAR_ADDR)
686                 result = dma_map_area(r, map.r1.base, map.r1.size,
687                         &tmp);
688         else
689                 result = dma_map_area(r, map.rm.size, map.r1.size,
690                         &tmp);
691
692         BUG_ON(result);
693
694         return result;
695 }
696
697 /**
698  * dma_region_free_linear - Free a linear dma mapping for a device.
699  * @r: Pointer to a struct ps3_dma_region.
700  *
701  * This routine will unmap all mapped areas and free the HV dma region.
702  */
703
704 static int dma_region_free_linear(struct ps3_dma_region *r)
705 {
706         int result;
707
708         result = dma_unmap_area(r, dma_lpar_to_bus(r, 0), map.rm.size);
709         BUG_ON(result);
710
711         result = dma_unmap_area(r, dma_lpar_to_bus(r, map.r1.base),
712                 map.r1.size);
713         BUG_ON(result);
714
715         result = dma_region_free(r);
716         BUG_ON(result);
717
718         return result;
719 }
720
721 /**
722  * dma_map_area_linear - Map an area of memory into a device dma region.
723  * @r: Pointer to a struct ps3_dma_region.
724  * @virt_addr: Starting virtual address of the area to map.
725  * @len: Length in bytes of the area to map.
726  * @bus_addr: A pointer to return the starting ioc bus address of the area to
727  * map.
728  *
729  * This routine just returns the coresponding bus address.  Actual mapping
730  * occurs in dma_region_create_linear().
731  */
732
733 static int dma_map_area_linear(struct ps3_dma_region *r,
734         unsigned long virt_addr, unsigned long len, unsigned long *bus_addr)
735 {
736         unsigned long phys_addr = is_kernel_addr(virt_addr) ? __pa(virt_addr)
737                 : virt_addr;
738         *bus_addr = dma_lpar_to_bus(r, ps3_mm_phys_to_lpar(phys_addr));
739         return 0;
740 }
741
742 /**
743  * dma_unmap_area_linear - Unmap an area of memory from a device dma region.
744  * @r: Pointer to a struct ps3_dma_region.
745  * @bus_addr: The starting ioc bus address of the area to unmap.
746  * @len: Length in bytes of the area to unmap.
747  *
748  * This routine does nothing.  Unmapping occurs in dma_region_free_linear().
749  */
750
751 static int dma_unmap_area_linear(struct ps3_dma_region *r,
752         unsigned long bus_addr, unsigned long len)
753 {
754         return 0;
755 }
756
757 int ps3_dma_region_create(struct ps3_dma_region *r)
758 {
759         return (USE_DYNAMIC_DMA)
760                 ? dma_region_create(r)
761                 : dma_region_create_linear(r);
762 }
763
764 int ps3_dma_region_free(struct ps3_dma_region *r)
765 {
766         return (USE_DYNAMIC_DMA)
767                 ? dma_region_free(r)
768                 : dma_region_free_linear(r);
769 }
770
771 int ps3_dma_map(struct ps3_dma_region *r, unsigned long virt_addr,
772         unsigned long len, unsigned long *bus_addr)
773 {
774         return (USE_DYNAMIC_DMA)
775                 ? dma_map_area(r, virt_addr, len, bus_addr)
776                 : dma_map_area_linear(r, virt_addr, len, bus_addr);
777 }
778
779 int ps3_dma_unmap(struct ps3_dma_region *r, unsigned long bus_addr,
780         unsigned long len)
781 {
782         return (USE_DYNAMIC_DMA) ? dma_unmap_area(r, bus_addr, len)
783                 : dma_unmap_area_linear(r, bus_addr, len);
784 }
785
786 /*============================================================================*/
787 /* system startup routines                                                    */
788 /*============================================================================*/
789
790 /**
791  * ps3_mm_init - initialize the address space state variables
792  */
793
794 void __init ps3_mm_init(void)
795 {
796         int result;
797
798         DBG(" -> %s:%d\n", __func__, __LINE__);
799
800         result = ps3_repository_read_mm_info(&map.rm.base, &map.rm.size,
801                 &map.total);
802
803         if (result)
804                 panic("ps3_repository_read_mm_info() failed");
805
806         map.rm.offset = map.rm.base;
807         map.vas_id = map.htab_size = 0;
808
809         /* this implementation assumes map.rm.base is zero */
810
811         BUG_ON(map.rm.base);
812         BUG_ON(!map.rm.size);
813
814         lmb_add(map.rm.base, map.rm.size);
815         lmb_analyze();
816
817         /* arrange to do this in ps3_mm_add_memory */
818         ps3_mm_region_create(&map.r1, map.total - map.rm.size);
819
820         DBG(" <- %s:%d\n", __func__, __LINE__);
821 }
822
823 /**
824  * ps3_mm_shutdown - final cleanup of address space
825  */
826
827 void ps3_mm_shutdown(void)
828 {
829         ps3_mm_region_destroy(&map.r1);
830         map.total = map.rm.size;
831 }