sys/boot/ofw/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 __FBSDID("$FreeBSD$");
  29
  30 /*
  31  * MD primitives supporting placement of module data
  32  *
  33  * XXX should check load address/size against memory top.
  34  */
  35 #include <stand.h>
  36
  37 #include "libofw.h"
  38
  39 #define READIN_BUF      (4 * 1024)
  40 #define PAGE_SIZE       0x1000
  41 #define PAGE_MASK       0x0fff
  42 #define MAPMEM_PAGE_INC 16
  43
  44
  45 #define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
  46
  47 static int
  48 ofw_mapmem(vm_offset_t dest, const size_t len)
  49 {
  50         void    *destp, *addr;
  51         size_t  dlen;
  52         size_t  resid;
  53         size_t  nlen;
  54         static vm_offset_t last_dest = 0;
  55         static size_t last_len = 0;
  56
  57         nlen = len;
  58         /*
  59          * Check to see if this region fits in a prior mapping.
  60          * Allocations are generally sequential, so only check
  61          * the last one.
  62          */
  63         if (dest >= last_dest &&
  64             (dest + len) <= (last_dest + last_len)) {
  65                 return (0);
  66         }
  67
  68         /*
  69          * Trim area covered by existing mapping, if any
  70          */
  71         if (dest < (last_dest + last_len)) {
  72                 nlen -= (last_dest + last_len) - dest;
  73                 dest = last_dest + last_len;
  74         }
  75
  76         destp = (void *)(dest & ~PAGE_MASK);
  77         resid = dest & PAGE_MASK;
  78
  79         /*
  80          * To avoid repeated mappings on small allocations,
  81          * never map anything less than MAPMEM_PAGE_INC pages at a time
  82          */
  83         if ((nlen + resid) < PAGE_SIZE*MAPMEM_PAGE_INC) {
  84                 dlen = PAGE_SIZE*MAPMEM_PAGE_INC;
  85         } else
  86                 dlen = roundup(nlen + resid, PAGE_SIZE);
  87
  88         if (OF_call_method("claim", memory, 3, 1, destp, dlen, 0, &addr)
  89             == -1) {
  90                 printf("ofw_mapmem: physical claim failed\n");
  91                 return (ENOMEM);
  92         }
  93
  94         if (OF_call_method("claim", mmu, 3, 1, destp, dlen, 0, &addr) == -1) {
  95                 printf("ofw_mapmem: virtual claim failed\n");
  96                 return (ENOMEM);
  97         }
  98
  99         if (OF_call_method("map", mmu, 4, 0, destp, destp, dlen, 0) == -1) {
 100                 printf("ofw_mapmem: map failed\n");
 101                 return (ENOMEM);
 102         }
 103
 104         last_dest = (vm_offset_t) destp;
 105         last_len  = dlen;
 106
 107         return (0);
 108 }
 109
 110 ssize_t
 111 ofw_copyin(const void *src, vm_offset_t dest, const size_t len)
 112 {
 113         if (ofw_mapmem(dest, len)) {
 114                 printf("ofw_copyin: map error\n");
 115                 return (0);
 116         }
 117
 118         bcopy(src, (void *)dest, len);
 119         return(len);
 120 }
 121
 122 ssize_t
 123 ofw_copyout(const vm_offset_t src, void *dest, const size_t len)
 124 {
 125         bcopy((void *)src, dest, len);
 126         return(len);
 127 }
 128
 129 ssize_t
 130 ofw_readin(const int fd, vm_offset_t dest, const size_t len)
 131 {
 132         void            *buf;
 133         size_t          resid, chunk, get;
 134         ssize_t         got;
 135         vm_offset_t     p;
 136
 137         p = dest;
 138
 139         chunk = min(READIN_BUF, len);
 140         buf = malloc(chunk);
 141         if (buf == NULL) {
 142                 printf("ofw_readin: buf malloc failed\n");
 143                 return(0);
 144         }
 145
 146         if (ofw_mapmem(dest, len)) {
 147                 printf("ofw_readin: map error\n");
 148                 free(buf);
 149                 return (0);
 150         }
 151
 152         for (resid = len; resid > 0; resid -= got, p += got) {
 153                 get = min(chunk, resid);
 154                 got = read(fd, buf, get);
 155
 156                 if (got <= 0) {
 157                         if (got < 0)
 158                                 printf("ofw_readin: read failed\n");
 159                         break;
 160                 }
 161
 162                 bcopy(buf, (void *)p, got);
 163         }
 164
 165         free(buf);
 166         return(len - resid);
 167 }