]> 4ch.mooo.com Git - 16.git/blob - src/testemm0.c
ok
[16.git] / src / testemm0.c
1 /* testemm.c
2  *
3  * Test program: Expanded Memory Manager functions
4  * (C) 2011-2012 Jonathan Campbell.
5  * Hackipedia DOS library.
6  *
7  * This code is licensed under the LGPL.
8  * <insert LGPL legal text here>
9  */
10
11 #include <stdlib.h>
12 #include <string.h>
13 #include <stdint.h>
14 #include <assert.h>
15 #include <stdio.h>
16 #include <conio.h>
17 #include <dos.h>
18
19 //#include "src/lib/doslib/cpu.h"
20 #include "src/lib/doslib/dos.h"
21 #include "src/lib/doslib/emm.h"
22 //#include <hw/dos/doswin.h>
23
24 static const char *message = "Hello world. How are you?";
25 static const char *message2 = "Pingas. Sup dawg. Hello world. Dork. Hahahajajaja.";
26 static char tmp[128],tmp2[128];
27 extern int probe_emm0();
28
29 #if 1
30 # define x_memcpy(a,b,c) memcpy(a,b,c)
31 #else
32 /* what have we come to when friggin' memcpy() causes a GPF?!? */
33 static void x_memcpy(unsigned char *dst,const unsigned char *src,size_t c) {
34         fprintf(stderr,"memcpy %p -> %p (%lu)\n",
35                 dst,src,(unsigned long)c);
36
37         while (c != 0) {
38             *dst++ = *src++;
39             c--;
40         }
41 }
42 #endif
43
44 int main() {
45         size_t message_l = strlen(message),message2_l = strlen(message2);
46
47         probe_dos();
48         printf("DOS version %x.%02u\n",dos_version>>8,dos_version&0xFF);
49         /*if (detect_windows()) {
50                 printf("I am running under Windows.\n");
51                 printf("    Mode: %s\n",windows_mode_str(windows_mode));
52                 printf("    Ver:  %x.%02u\n",windows_version>>8,windows_version&0xFF);
53         }
54         else {
55                 printf("Not running under Windows or OS/2\n");
56         }*/
57
58         sanity();
59         if (probe_emm()) {
60                 int h1,h2,h3;
61
62                 sanity();
63                 printf("Expanded memory manager present. Status = 0x%02x Page frame @0x%04x v%x.%x\n",emm_status,emm_page_frame_segment,emm_version>>4,emm_version&0x0F);
64                 emm_update_page_count();
65                 sanity();
66                 printf("  Unallocated pages:     %u (%luKB)\n",
67                         emm_unallocated_pages,
68                         (unsigned long)emm_unallocated_pages << 4UL); /* 2^14 = 16384 */
69                 printf("  Total pages:           %u (%luKB)\n",
70                         emm_total_pages,
71                         (unsigned long)emm_total_pages << 4UL);
72                 printf("  Physical pages:        %u (%luKB)\n",
73                         emm_phys_pages,
74                         (unsigned long)emm_phys_pages << 4UL);
75
76                 while (getch() != 13);
77                 sanity();
78
79                 /* print out the mapping table, if available */
80                 if (emm_phys_map != NULL) {
81                         struct emm_phys_page_map *me;
82                         unsigned int i;
83
84                         printf("Physical page to segment table\n");
85                         for (i=0;i < emm_phys_pages;i++) {
86                                 me = emm_phys_map + i;
87                                 printf("  %02x: 0x%04x",me->number,me->segment);
88                                 if ((i%5) == 4) printf("\n");
89                         }
90                         printf("\n");
91                         sanity();
92                 }
93
94                 printf("Allocating EMM pages (1): ");
95                 h1 = emm_alloc_pages(1);
96                 sanity();
97                 if (h1 >= 0) {
98                         printf("OK, handle=%u\n",h1);
99                         if (!emm_free_pages(h1)) printf("cannot free\n");
100                 }
101                 else printf("FAILED\n");
102
103                 printf("Allocating EMM pages (%luKB): ", (dword)emm_unallocated_pages << 4UL);
104                 h1 = emm_alloc_pages(emm_unallocated_pages);
105                 sanity();
106                 if (h1 >= 0) printf("OK, handle=%u\n",h1);
107                 else printf("FAILED\n");
108
109 //              printf("Allocating EMM pages (1.6MB): ");
110                 //h2 = emm_alloc_pages(0x19999AUL >> 14UL);
111                 /*h2 = emm_alloc_pages(1);
112                 sanity();
113                 if (h2 >= 0) printf("OK, handle=%u\n",h2);
114                 else printf("FAILED\n");
115
116                 //printf("Allocating EMM pages (12MB): ");
117                 //h3 = emm_alloc_pages(0xC00000UL >> 14UL);
118                 h3 = emm_alloc_pages(1);
119                 sanity();
120                 if (h3 >= 0) printf("OK, handle=%u\n",h3);
121                 else printf("FAILED\n");*/
122
123                 while (getch() != 13);
124
125                 if (h1 >= 0 && !emm_free_pages(h1)) printf("Cannot free\n");
126                 sanity();
127                 /*if (h2 >= 0 && !emm_free_pages(h2)) printf("Cannot free\n");
128                 sanity();
129                 if (h3 >= 0 && !emm_free_pages(h3)) printf("Cannot free\n");
130                 sanity();*/
131
132                 printf("Allocating EMM pages (32KB): ");
133                 h1 = emm_alloc_pages(2);
134                 sanity();
135                 if (h1 >= 0) {
136                         printf("OK, handle=%u\n",h1);
137                         if (emm_map_page(h1,/*physical*/0,/*logical*/0)) {
138                                 unsigned int segm = emm_last_phys_page_segment(0);
139                                 printf("Seg %04x\n",segm);
140                                 sanity();
141                                 if (segm > 0) {
142 #if TARGET_MSDOS == 16
143                                         char far *ptr = MK_FP(segm,0);
144 #else
145                                         char *ptr = (char*)(segm << 4UL);
146 #endif
147
148 #if TARGET_MSDOS == 16
149                                         _fmemcpy(ptr,(char far*)message,message_l+1);
150                                         _fmemcpy((char far*)tmp,ptr,message_l+1);
151 #else
152                                         x_memcpy(ptr,message,message_l+1);
153                                         x_memcpy(tmp,ptr,message_l+1);
154 #endif
155                                         printf("After writing message there, I read back: '%s'\n",tmp);
156
157                                         if (!emm_map_page(h1,0,1)) printf("Cannot remap\n");
158
159 #if TARGET_MSDOS == 16
160                                         _fmemcpy(ptr,(char far*)message2,message2_l+1);
161                                         _fmemcpy((char far*)tmp,ptr,message2_l+1);
162 #else
163                                         x_memcpy(ptr,message2,message2_l+1);
164                                         x_memcpy(tmp,ptr,message2_l+1);
165 #endif
166                                         printf("After mapping to page 2 and writing there, I read back: '%s'\n",tmp);
167
168                                         if (!emm_map_page(h1,0,0)) printf("Cannot remap\n");
169
170 #if TARGET_MSDOS == 16
171                                         _fmemcpy((char far*)tmp,ptr,message_l+1);
172 #else
173                                         x_memcpy(tmp,ptr,message_l+1);
174 #endif
175                                         printf("After mapping back to 1, I read back: '%s'\n",tmp);
176
177                                         if (emm_map_page(h1,0,2)) printf("Whoops, I was able to map logical pages beyond what I allocated\n");
178                                 }
179                                 else {
180                                         printf("Cannot get segment\n");
181                                 }
182                                 if (!emm_map_page(h1,0,0xFFFF)) printf("Cannot unmap\n");
183                         }
184                         else {
185                                 printf("Cannot map\n");
186                         }
187                         if (!emm_free_pages(h1)) printf("Cannot free\n");
188                 }
189                 else printf("FAILED\n");
190
191                 printf("Allocating EMM pages (32KB): ");
192                 h1 = emm_alloc_pages(2);
193                 if (h1 >= 0) {
194                         printf("OK, handle=%u\n",h1);
195                         if (    emm_map_page(h1,/*physical*/0,/*logical*/0) &&
196                                 emm_map_page(h1,/*physical*/1,/*logical*/1)) {
197                                 unsigned int seg1 = emm_last_phys_page_segment(0);
198                                 unsigned int seg2 = emm_last_phys_page_segment(1);
199                                 printf("Seg %04x,%04x\n",seg1,seg2);
200                                 if (seg1 > 0 && seg2 > 0) {
201 #if TARGET_MSDOS == 16
202                                         char far *ptr1 = MK_FP(seg1,0);
203                                         char far *ptr2 = MK_FP(seg2,0);
204 #else
205                                         char *ptr1 = (char*)(seg1 << 4UL);
206                                         char *ptr2 = (char*)(seg2 << 4UL);
207 #endif
208
209 #if TARGET_MSDOS == 16
210                                         _fmemcpy(ptr1,(char far*)message,message_l+1);
211                                         _fmemcpy(ptr2,(char far*)message2,message2_l+1);
212 #else
213                                         memcpy(ptr1,message,message_l+1);
214                                         memcpy(ptr2,message2,message2_l+1);
215 #endif
216
217 #if TARGET_MSDOS == 16
218                                         _fmemcpy((char far*)tmp,ptr1,message_l+1);
219                                         _fmemcpy((char far*)tmp2,ptr2,message2_l+1);
220 #else
221                                         memcpy(tmp,ptr1,message_l+1);
222                                         memcpy(tmp2,ptr2,message2_l+1);
223 #endif
224
225                                         printf("After writing message there, I read back:\n'%s'\n'%s'\n",tmp,tmp2);
226
227                                         /* now swap the pages */
228                                         if (!emm_map_page(h1,1,0)) printf("cannot map log 1 -> phys 0\n");
229                                         if (!emm_map_page(h1,0,1)) printf("cannot map log 0 -> phys 1\n");
230
231 #if TARGET_MSDOS == 16
232                                         _fmemcpy((char far*)tmp,ptr1,message2_l+1);
233                                         _fmemcpy((char far*)tmp2,ptr2,message_l+1);
234 #else
235                                         memcpy(tmp,ptr1,message2_l+1);
236                                         memcpy(tmp2,ptr2,message_l+1);
237 #endif
238
239                                         printf("After swapping pages, I read back:\n'%s'\n'%s'\n",tmp,tmp2);
240                                 }
241                                 else {
242                                         printf("Cannot get segment\n");
243                                 }
244                                 if (!emm_map_page(h1,0,0xFFFF) || !emm_map_page(h1,1,0xFFFF)) printf("Cannot unmap\n");
245                         }
246                         else {
247                                 printf("Cannot map\n");
248                         }
249                         if (!emm_free_pages(h1)) printf("Cannot free\n");
250                 }
251                 else printf("FAILED\n");
252
253                 getch();
254
255                 /* we do this test because Microsoft EMM386.EXE seems to max out at 32MB.
256                  * the host could have 256MB of total memory and it would still report 32MB in EMS */
257                 printf("we do this test because Microsoft EMM386.EXE seems to max out at 32MB.\n the host could have 256MB of total memory and it would still report 32MB in EMS");
258                 printf("Allocating EMM pages (48MB): ");
259                 h1 = emm_alloc_pages((48UL << 20UL) >> 14UL);
260                 if (h1 >= 0) {
261                         printf("OK, handle=%u\n",h1);
262                         if (!emm_free_pages(h1)) printf("cannot free\n");
263                 }
264                 else printf("FAILED\n");
265
266                 printf("Allocating EMM pages (96MB): ");
267                 h1 = emm_alloc_pages((96UL << 20UL) >> 14UL);
268                 if (h1 >= 0) {
269                         printf("OK, handle=%u\n",h1);
270                         if (!emm_free_pages(h1)) printf("cannot free\n");
271                 }
272                 else printf("FAILED\n");
273         }
274
275         return 0;
276 }