stand/libofw/ofw_copy.c

   1 /*-
   2  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 /*
  29  * MD primitives supporting placement of module data
  30  *
  31  * XXX should check load address/size against memory top.
  32  */
  33 #include <stand.h>
  34
  35 #include "libofw.h"
  36
  37 #define READIN_BUF      (4 * 1024)
  38 #define PAGE_SIZE       0x1000
  39 #define PAGE_MASK       0x0fff
  40 #define MAPMEM_PAGE_INC 128 /* Half-MB at a time */
  41
  42
  43 #define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
  44
  45 static int
  46 ofw_mapmem(vm_offset_t dest, const size_t len)
  47 {
  48         void    *destp, *addr;
  49         size_t  dlen;
  50         size_t  resid;
  51         size_t  nlen;
  52         static vm_offset_t last_dest = 0;
  53         static size_t last_len = 0;
  54
  55         nlen = len;
  56         /*
  57          * Check to see if this region fits in a prior mapping.
  58          * Allocations are generally sequential, so only check
  59          * the last one.
  60          */
  61         if (dest >= last_dest &&
  62             (dest + len) <= (last_dest + last_len)) {
  63                 return (0);
  64         }
  65
  66         /*
  67          * Trim area covered by existing mapping, if any
  68          */
  69         if (dest < (last_dest + last_len) && dest >= last_dest) {
  70                 nlen -= (last_dest + last_len) - dest;
  71                 dest = last_dest + last_len;
  72         }
  73
  74         destp = (void *)(dest & ~PAGE_MASK);
  75         resid = dest & PAGE_MASK;
  76
  77         /*
  78          * To avoid repeated mappings on small allocations,
  79          * never map anything less than MAPMEM_PAGE_INC pages at a time
  80          */
  81         if ((nlen + resid) < PAGE_SIZE*MAPMEM_PAGE_INC) {
  82                 dlen = PAGE_SIZE*MAPMEM_PAGE_INC;
  83         } else
  84                 dlen = roundup(nlen + resid, PAGE_SIZE);
  85
  86         if (OF_call_method("claim", memory, 3, 1, destp, dlen, 0, &addr)
  87             == -1) {
  88                 printf("ofw_mapmem: physical claim failed\n");
  89                 return (ENOMEM);
  90         }
  91
  92         /*
  93          * We only do virtual memory management when real_mode is false.
  94          */
  95         if (real_mode == 0) {
  96                 if (OF_call_method("claim", mmu, 3, 1, destp, dlen, 0, &addr)
  97                     == -1) {
  98                         printf("ofw_mapmem: virtual claim failed\n");
  99                         return (ENOMEM);
 100                 }
 101
 102                 if (OF_call_method("map", mmu, 4, 0, destp, destp, dlen, 0)
 103                     == -1) {
 104                         printf("ofw_mapmem: map failed\n");
 105                         return (ENOMEM);
 106                 }
 107         }
 108         last_dest = (vm_offset_t) destp;
 109         last_len  = dlen;
 110
 111         return (0);
 112 }
 113
 114 ssize_t
 115 ofw_copyin(const void *src, vm_offset_t dest, const size_t len)
 116 {
 117         if (ofw_mapmem(dest, len)) {
 118                 printf("ofw_copyin: map error\n");
 119                 return (0);
 120         }
 121
 122         bcopy(src, (void *)dest, len);
 123         return(len);
 124 }
 125
 126 ssize_t
 127 ofw_copyout(const vm_offset_t src, void *dest, const size_t len)
 128 {
 129         bcopy((void *)src, dest, len);
 130         return(len);
 131 }
 132
 133 ssize_t
 134 ofw_readin(readin_handle_t fd, vm_offset_t dest, const size_t len)
 135 {
 136         void            *buf;
 137         size_t          resid, chunk, get;
 138         ssize_t         got;
 139         vm_offset_t     p;
 140
 141         p = dest;
 142
 143         chunk = min(READIN_BUF, len);
 144         buf = malloc(chunk);
 145         if (buf == NULL) {
 146                 printf("ofw_readin: buf malloc failed\n");
 147                 return(0);
 148         }
 149
 150         if (ofw_mapmem(dest, len)) {
 151                 printf("ofw_readin: map error\n");
 152                 free(buf);
 153                 return (0);
 154         }
 155
 156         for (resid = len; resid > 0; resid -= got, p += got) {
 157                 get = min(chunk, resid);
 158                 got = VECTX_READ(fd, buf, get);
 159
 160                 if (got <= 0) {
 161                         if (got < 0)
 162                                 printf("ofw_readin: read failed\n");
 163                         break;
 164                 }
 165
 166                 bcopy(buf, (void *)p, got);
 167         }
 168
 169         free(buf);
 170         return(len - resid);
 171 }