initial commit
[freebsd-arm:freebsd-arm.git] / 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 }