cp/mm/dat.c

   1 /*
   2  * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
   3  *
   4  * This file is released under the GPLv2.  See the COPYING file for more
   5  * details.
   6  */
   7
   8 #include <page.h>
   9 #include <buddy.h>
  10 #include <dat.h>
  11 #include <mm.h>
  12
  13 static void *alloc_table(int order)
  14 {
  15         struct page *p;
  16
  17         p = alloc_pages(order, ZONE_NORMAL);
  18         BUG_ON(!p);
  19         memset(page_to_addr(p), 0xff, PAGE_SIZE << order);
  20
  21         return page_to_addr(p);
  22 }
  23
  24 /**
  25  * dat_insert_page - insert a virt->phy mapping into an address space
  26  * @as:         address space to add the mapping to
  27  * @phy:        physical address to add
  28  * @virt:       virtual address to add
  29  */
  30 int dat_insert_page(struct address_space *as, u64 phy, u64 virt)
  31 {
  32         struct dat_rte *region;
  33         struct dat_ste *segment;
  34         struct dat_pte *page;
  35         void *ptr;
  36
  37         region = as->region_table;
  38
  39         if (!region) {
  40                 if (!as->segment_table)
  41                         /*
  42                          * Need to allocate the segment table
  43                          *
  44                          * max of 2048 * 8-byte entries = 16 kbytes
  45                          */
  46                         as->segment_table = alloc_table(2);
  47
  48                 segment = as->segment_table;
  49
  50                 goto walk_segment;
  51         }
  52
  53         if (DAT_RX(virt)) {
  54                 FIXME("we don't support storage >2GB");
  55                 BUG();
  56         }
  57
  58         if (region->origin == 0xfffffffffffffUL) {
  59                 /*
  60                  * Need to allocate the segment table
  61                  *
  62                  * max of 2048 * 8-byte entries = 16 kbytes
  63                  */
  64                 ptr = alloc_table(2);
  65
  66                 region->origin = ADDR_TO_RTE_ORIGIN((u64) ptr);
  67
  68                 region->tf = 0;
  69                 region->i = 0;
  70                 region->tt = DAT_RTE_TT_RTT;
  71                 region->tl = 3;
  72                 region->__reserved0 = 0;
  73                 region->__reserved1 = 0;
  74         }
  75
  76         segment = RTE_ORIGIN_TO_ADDR(region->origin);
  77
  78 walk_segment:
  79         segment += DAT_SX(virt);
  80
  81         if (segment->origin == 0x1fffffffffffffUL) {
  82                 /*
  83                  * Need to allocate the page table
  84                  *
  85                  * max of 256 * 8-byte entries = 2048 bytes
  86                  */
  87                 ptr = alloc_table(0);
  88
  89                 segment->origin = ADDR_TO_STE_ORIGIN((u64) ptr);
  90                 segment->p = 0;
  91                 segment->i = 0;
  92                 segment->c = 0;
  93                 segment->tt = DAT_STE_TT_ST;
  94                 segment->__reserved0 = 0;
  95                 segment->__reserved1 = 0;
  96                 segment->__reserved2 = 0;
  97         }
  98
  99         page = STE_ORIGIN_TO_ADDR(segment->origin);
 100         page += DAT_PX(virt);
 101
 102         page->pfra = phy >> PAGE_SHIFT;
 103         page->i = 0;
 104         page->p = 0;
 105         page->__zero0 = 0;
 106         page->__zero1 = 0;
 107         page->__reserved = 0;
 108
 109         return 0;
 110 }
 111
 112 void setup_dat(void)
 113 {
 114         /* nothing to do! */
 115 }
 116
 117 void load_as(struct address_space *as)
 118 {
 119         struct dat_td cr1;
 120
 121         BUG_ON(!as->segment_table);
 122
 123         /*
 124          * Load up the PASCE (cr1)
 125          */
 126         memset(&cr1, 0, sizeof(struct dat_td));
 127         cr1.origin = ((u64)as->segment_table) >> 12;
 128         cr1.dt = DAT_TD_DT_ST;
 129         cr1.tl = 3;
 130
 131         asm volatile(
 132                 "       lctlg   1,1,%0\n"
 133         : /* output */
 134         : /* input */
 135           "m" (cr1)
 136         );
 137 }
 138
 139 /* memcpy that pays attention to page boundary crossing; *len contains the
 140  * number of bytes to copy on entry, and at return, the number of bytes
 141  * copied */
 142 int __memcpy_tofrom_guest(u64 guest_addr, void *data, u64 *len, int from)
 143 {
 144         u8 *_data = data;
 145         u64 host_addr;
 146         u64 copy_len;
 147         u64 copied;
 148         int ret = 0;
 149
 150         for(copied = 0; *len; ) {
 151                 /* walk the page tables to find the real page frame */
 152                 ret = virt2phy_current(guest_addr, &host_addr);
 153                 if (ret)
 154                         break;
 155
 156                 /* copy this much this time around... until the end of the page, or
 157                  * the while thing that's left
 158                  */
 159                 copy_len = min(PAGE_SIZE - (host_addr & PAGE_MASK), *len);
 160
 161                 /* COPY! */
 162                 if (from)
 163                         memcpy(_data + copied, (void*)host_addr, copy_len);
 164                 else
 165                         memcpy((void*)host_addr, _data + copied, copy_len);
 166
 167                 copied += copy_len;
 168                 *len -= copy_len;
 169         }
 170
 171         *len = copied;
 172         return ret;
 173 }