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