1 |
cebix |
1.1 |
/* |
2 |
|
|
* sheep_driver.c - Low memory and ROM access driver for SheepShaver and |
3 |
|
|
* Basilisk II on PowerPC systems |
4 |
|
|
* |
5 |
|
|
* SheepShaver (C) 1997-2000 Mar"c Hellwig and Christian Bauer |
6 |
|
|
* Basilisk II (C) 1997-2000 Christian Bauer |
7 |
|
|
* |
8 |
|
|
* This program is free software; you can redistribute it and/or modify |
9 |
|
|
* it under the terms of the GNU General Public License as published by |
10 |
|
|
* the Free Software Foundation; either version 2 of the License, or |
11 |
|
|
* (at your option) any later version. |
12 |
|
|
* |
13 |
|
|
* This program is distributed in the hope that it will be useful, |
14 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 |
|
|
* GNU General Public License for more details. |
17 |
|
|
* |
18 |
|
|
* You should have received a copy of the GNU General Public License |
19 |
|
|
* along with this program; if not, write to the Free Software |
20 |
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
21 |
|
|
*/ |
22 |
|
|
|
23 |
|
|
#include <drivers/KernelExport.h> |
24 |
|
|
#include <drivers/Drivers.h> |
25 |
|
|
#include <stdio.h> |
26 |
|
|
#include <stdlib.h> |
27 |
|
|
#include <stdarg.h> |
28 |
|
|
#include <string.h> |
29 |
|
|
#include <fcntl.h> |
30 |
|
|
|
31 |
|
|
#include "sheep_driver.h" |
32 |
|
|
|
33 |
|
|
#define DEBUG 0 |
34 |
|
|
|
35 |
|
|
#if DEBUG==1 |
36 |
|
|
#define bug pprintf |
37 |
|
|
#elif DEBUG==2 |
38 |
|
|
#define bug dprintf |
39 |
|
|
#endif |
40 |
|
|
|
41 |
|
|
#if DEBUG |
42 |
|
|
#define D(x) (x) |
43 |
|
|
#else |
44 |
|
|
#define D(x) ; |
45 |
|
|
#endif |
46 |
|
|
|
47 |
|
|
#define PORT_NAME "sheep_driver installed" |
48 |
|
|
|
49 |
|
|
|
50 |
|
|
/* |
51 |
|
|
* For debugging |
52 |
|
|
*/ |
53 |
|
|
|
54 |
|
|
static int pprintf(const char* format, ...) |
55 |
|
|
{ |
56 |
|
|
port_id PortNum; |
57 |
|
|
int len, ret; |
58 |
|
|
char Buffer[1024]; |
59 |
|
|
va_list ap; |
60 |
|
|
|
61 |
|
|
if ((PortNum = find_port("PortLogger")) == B_NAME_NOT_FOUND) |
62 |
|
|
return(PortNum); |
63 |
|
|
for (len=0; len<1024; len++) |
64 |
|
|
Buffer[len]='\0'; |
65 |
|
|
va_start(ap, format); |
66 |
|
|
vsprintf(Buffer, format, ap); |
67 |
|
|
ret = write_port(PortNum, 0, Buffer, strlen(Buffer)); |
68 |
|
|
return ret; |
69 |
|
|
} |
70 |
|
|
|
71 |
|
|
|
72 |
|
|
/* |
73 |
|
|
* Page table functions |
74 |
|
|
*/ |
75 |
|
|
|
76 |
|
|
static uint32 *pte_address = 0; |
77 |
|
|
static uint32 vsid; |
78 |
|
|
static uint32 table_size; |
79 |
|
|
|
80 |
|
|
static status_t map_page(uint32 ea, uint32 ra, uint32 **free_pte, uint32 bits) |
81 |
|
|
{ |
82 |
|
|
int i; |
83 |
|
|
int pte_class; |
84 |
|
|
uint32 hash1, hash2, api, *pteg1, *pteg2; |
85 |
|
|
|
86 |
|
|
D(bug("Trying to map EA %p -> RA %p\n", ea, ra)); |
87 |
|
|
|
88 |
|
|
// Find PTEG addresses for given EA |
89 |
|
|
hash1 = (vsid & 0x7ffff) ^ ((ea >> 12) & 0xffff); |
90 |
|
|
hash2 = ~hash1 & 0x7ffff; |
91 |
|
|
api = (ea >> 22) & 0x3f; |
92 |
|
|
pteg1 = (uint32 *)((uint32)pte_address + ((hash1 << 6) & (table_size - 1))); |
93 |
|
|
pteg2 = (uint32 *)((uint32)pte_address + ((hash2 << 6) & (table_size - 1))); |
94 |
|
|
D(bug("PTEG1 at %p, PTEG2 at %p\n", pteg1, pteg2)); |
95 |
|
|
|
96 |
|
|
// Search all 8 PTEs of each PTEG |
97 |
|
|
*free_pte = NULL; |
98 |
|
|
pte_class = 0; |
99 |
|
|
for (i=0; i<8; i++) { |
100 |
|
|
D(bug(" found %08lx %08lx\n", pteg1[i*2], pteg1[i*2+1])); |
101 |
|
|
if (pteg1[i*2] == (0x80000000 | (vsid << 7) | (pte_class << 6) | api)) { |
102 |
|
|
*free_pte = pteg1 + i*2; |
103 |
|
|
D(bug(" existing PTE found (PTEG1)\n")); |
104 |
|
|
break; |
105 |
|
|
} else if (!pteg1[i*2]) { |
106 |
|
|
*free_pte = pteg1 + i*2; |
107 |
|
|
D(bug(" free PTE found (PTEG1)\n")); |
108 |
|
|
break; |
109 |
|
|
} |
110 |
|
|
} |
111 |
|
|
if (*free_pte == NULL) { |
112 |
|
|
pte_class = 1; |
113 |
|
|
for (i=0; i<8; i++) { |
114 |
|
|
D(bug(" found %08lx %08lx\n", pteg2[i*2], pteg2[i*2+1])); |
115 |
|
|
if (pteg2[i*2] == (0x80000000 | (vsid << 7) | (pte_class << 6) | api)) { |
116 |
|
|
*free_pte = pteg2 + i*2; |
117 |
|
|
D(bug(" existing PTE found (PTEG2)\n")); |
118 |
|
|
break; |
119 |
|
|
} else if (!pteg2[i*2]) { |
120 |
|
|
*free_pte = pteg2 + i*2; |
121 |
|
|
D(bug(" free PTE found (PTEG2)\n")); |
122 |
|
|
break; |
123 |
|
|
} |
124 |
|
|
} |
125 |
|
|
} |
126 |
|
|
|
127 |
|
|
// Remap page |
128 |
|
|
if (*free_pte == NULL) { |
129 |
|
|
D(bug(" No free PTE found :-(\m")); |
130 |
|
|
return B_DEVICE_FULL; |
131 |
|
|
} else { |
132 |
|
|
(*free_pte)[0] = 0x80000000 | (vsid << 7) | (pte_class << 6) | api; |
133 |
|
|
(*free_pte)[1] = ra | bits; |
134 |
|
|
D(bug(" written %08lx %08lx to PTE\n", (*free_pte)[0], (*free_pte)[1])); |
135 |
|
|
return B_NO_ERROR; |
136 |
|
|
} |
137 |
|
|
} |
138 |
|
|
|
139 |
|
|
static status_t remap_page(uint32 *free_pte, uint32 ra, uint32 bits) |
140 |
|
|
{ |
141 |
|
|
D(bug("Remapping PTE %p -> RA %p\n", free_pte, ra)); |
142 |
|
|
|
143 |
|
|
// Remap page |
144 |
|
|
if (free_pte == NULL) { |
145 |
|
|
D(bug(" Invalid PTE :-(\n")); |
146 |
|
|
return B_BAD_ADDRESS; |
147 |
|
|
} else { |
148 |
|
|
free_pte[1] = ra | bits; |
149 |
|
|
D(bug(" written %08lx %08lx to PTE\n", free_pte[0], free_pte[1])); |
150 |
|
|
return B_NO_ERROR; |
151 |
|
|
} |
152 |
|
|
} |
153 |
|
|
|
154 |
|
|
|
155 |
|
|
/* |
156 |
|
|
* Foward declarations for hook functions |
157 |
|
|
*/ |
158 |
|
|
|
159 |
|
|
static status_t sheep_open(const char *name, uint32 flags, void **cookie); |
160 |
|
|
static status_t sheep_close(void *cookie); |
161 |
|
|
static status_t sheep_free(void *cookie); |
162 |
|
|
static status_t sheep_control(void *cookie, uint32 op, void *data, size_t len); |
163 |
|
|
static status_t sheep_read(void *cookie, off_t pos, void *data, size_t *len); |
164 |
|
|
static status_t sheep_write(void *cookie, off_t pos, const void *data, size_t *len); |
165 |
|
|
|
166 |
|
|
|
167 |
|
|
/* |
168 |
|
|
* Version of our driver |
169 |
|
|
*/ |
170 |
|
|
|
171 |
|
|
int32 api_version = B_CUR_DRIVER_API_VERSION; |
172 |
|
|
|
173 |
|
|
|
174 |
|
|
/* |
175 |
|
|
* Device_hooks structure - has function pointers to the |
176 |
|
|
* various entry points for device operations |
177 |
|
|
*/ |
178 |
|
|
|
179 |
|
|
static device_hooks my_device_hooks = { |
180 |
|
|
&sheep_open, |
181 |
|
|
&sheep_close, |
182 |
|
|
&sheep_free, |
183 |
|
|
&sheep_control, |
184 |
|
|
&sheep_read, |
185 |
|
|
&sheep_write, |
186 |
|
|
NULL, |
187 |
|
|
NULL, |
188 |
|
|
NULL, |
189 |
|
|
NULL |
190 |
|
|
}; |
191 |
|
|
|
192 |
|
|
|
193 |
|
|
/* |
194 |
|
|
* List of device names to be returned by publish_devices() |
195 |
|
|
*/ |
196 |
|
|
|
197 |
|
|
static char *device_name_list[] = { |
198 |
|
|
"sheep", |
199 |
|
|
0 |
200 |
|
|
}; |
201 |
|
|
|
202 |
|
|
|
203 |
|
|
/* |
204 |
|
|
* Init - do nothing |
205 |
|
|
*/ |
206 |
|
|
|
207 |
|
|
status_t init_hardware(void) |
208 |
|
|
{ |
209 |
|
|
#if DEBUG==2 |
210 |
|
|
set_dprintf_enabled(true); |
211 |
|
|
#endif |
212 |
|
|
D(bug("init_hardware()\n")); |
213 |
|
|
return B_NO_ERROR; |
214 |
|
|
} |
215 |
|
|
|
216 |
|
|
status_t init_driver(void) |
217 |
|
|
{ |
218 |
|
|
D(bug("init_driver()\n")); |
219 |
|
|
return B_NO_ERROR; |
220 |
|
|
} |
221 |
|
|
|
222 |
|
|
void uninit_driver(void) |
223 |
|
|
{ |
224 |
|
|
D(bug("uninit_driver()\n")); |
225 |
|
|
} |
226 |
|
|
|
227 |
|
|
|
228 |
|
|
/* |
229 |
|
|
* publish_devices - return list of device names implemented by this driver |
230 |
|
|
*/ |
231 |
|
|
|
232 |
|
|
const char **publish_devices(void) |
233 |
|
|
{ |
234 |
|
|
return device_name_list; |
235 |
|
|
} |
236 |
|
|
|
237 |
|
|
|
238 |
|
|
/* |
239 |
|
|
* find_device - return device hooks for a specific device name |
240 |
|
|
*/ |
241 |
|
|
|
242 |
|
|
device_hooks *find_device(const char *name) |
243 |
|
|
{ |
244 |
|
|
if (!strcmp(name, device_name_list[0])) |
245 |
|
|
return &my_device_hooks; |
246 |
|
|
|
247 |
|
|
return NULL; |
248 |
|
|
} |
249 |
|
|
|
250 |
|
|
|
251 |
|
|
/* |
252 |
|
|
* sheep_open - hook function for the open call. |
253 |
|
|
*/ |
254 |
|
|
|
255 |
|
|
static status_t sheep_open(const char *name, uint32 flags, void **cookie) |
256 |
|
|
{ |
257 |
|
|
return B_NO_ERROR; |
258 |
|
|
} |
259 |
|
|
|
260 |
|
|
|
261 |
|
|
/* |
262 |
|
|
* sheep_close - hook function for the close call. |
263 |
|
|
*/ |
264 |
|
|
|
265 |
|
|
static status_t sheep_close(void *cookie) |
266 |
|
|
{ |
267 |
|
|
return B_NO_ERROR; |
268 |
|
|
} |
269 |
|
|
|
270 |
|
|
|
271 |
|
|
/* |
272 |
|
|
* sheep_free - hook function to free the cookie returned |
273 |
|
|
* by the open hook. Since the open hook did not return |
274 |
|
|
* a cookie, this is a no-op. |
275 |
|
|
*/ |
276 |
|
|
|
277 |
|
|
static status_t sheep_free(void *cookie) |
278 |
|
|
{ |
279 |
|
|
return B_NO_ERROR; |
280 |
|
|
} |
281 |
|
|
|
282 |
|
|
|
283 |
|
|
/* |
284 |
|
|
* sheep_control - hook function for the ioctl call |
285 |
|
|
*/ |
286 |
|
|
|
287 |
|
|
static asm void inval_tlb(uint32 ea) |
288 |
|
|
{ |
289 |
|
|
isync |
290 |
|
|
tlbie r3 |
291 |
|
|
sync |
292 |
|
|
blr |
293 |
|
|
} |
294 |
|
|
|
295 |
|
|
static asm void tlbsync(void) |
296 |
|
|
{ |
297 |
|
|
machine 604 |
298 |
|
|
tlbsync |
299 |
|
|
sync |
300 |
|
|
blr |
301 |
|
|
} |
302 |
|
|
|
303 |
|
|
static status_t sheep_control(void *cookie, uint32 op, void *data, size_t len) |
304 |
|
|
{ |
305 |
|
|
static void *block; |
306 |
|
|
static void *block_aligned; |
307 |
|
|
physical_entry pe[2]; |
308 |
|
|
system_info sysinfo; |
309 |
|
|
area_id id; |
310 |
|
|
area_info info; |
311 |
|
|
cpu_status cpu_st; |
312 |
|
|
status_t res; |
313 |
|
|
uint32 ra0, ra1; |
314 |
|
|
uint32 *free_pte_0, *free_pte_1; |
315 |
|
|
int i; |
316 |
|
|
|
317 |
|
|
D(bug("control(%d) data %p, len %08x\n", op, data, len)); |
318 |
|
|
|
319 |
|
|
switch (op) { |
320 |
|
|
case SHEEP_UP: |
321 |
|
|
|
322 |
|
|
// Already messed up? Then do nothing now |
323 |
|
|
if (find_port(PORT_NAME) != B_NAME_NOT_FOUND) |
324 |
|
|
return B_NO_ERROR; |
325 |
|
|
|
326 |
|
|
// Get system info |
327 |
|
|
get_system_info(&sysinfo); |
328 |
|
|
|
329 |
|
|
// Prepare replacement memory |
330 |
|
|
block = malloc(B_PAGE_SIZE * 3); |
331 |
|
|
D(bug("3 pages malloc()ed at %p\n", block)); |
332 |
|
|
block_aligned = (void *)(((uint32)block + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE-1)); |
333 |
|
|
D(bug("Address aligned to %p\n", block_aligned)); |
334 |
|
|
res = lock_memory(block_aligned, B_PAGE_SIZE * 2, 0); |
335 |
|
|
if (res < 0) |
336 |
|
|
return res; |
337 |
|
|
|
338 |
|
|
// Get memory mapping |
339 |
|
|
D(bug("Memory locked\n")); |
340 |
|
|
res = get_memory_map(block_aligned, B_PAGE_SIZE * 2, pe, 2); |
341 |
|
|
D(bug("get_memory_map returned %d\n", res)); |
342 |
|
|
if (res != B_NO_ERROR) |
343 |
|
|
return res; |
344 |
|
|
|
345 |
|
|
// Find PTE table area |
346 |
|
|
id = find_area("pte_table"); |
347 |
|
|
get_area_info(id, &info); |
348 |
|
|
pte_address = (uint32 *)info.address; |
349 |
|
|
D(bug("PTE table seems to be at %p\n", pte_address)); |
350 |
|
|
table_size = info.size; |
351 |
|
|
D(bug("PTE table size: %dKB\n", table_size / 1024)); |
352 |
|
|
|
353 |
|
|
// Disable interrupts |
354 |
|
|
cpu_st = disable_interrupts(); |
355 |
|
|
|
356 |
|
|
// Find vsid and real addresses of replacement memory |
357 |
|
|
for (i=0; i<table_size/8; i++) { |
358 |
|
|
if (((uint32)pe[0].address & 0xfffff000)==(pte_address[i*2+1]&0xfffff000)) { |
359 |
|
|
D(bug("Found page 0 PtePos %04x V%x VSID %03x H%x API %02x RPN %03x R%1x C%1x WIMG%1x PP%1x \n", |
360 |
|
|
i << 2, |
361 |
|
|
((pte_address[i*2]&0x80000000) >> 31),((pte_address[i*2]&0x7fffff80) >> 7), |
362 |
|
|
((pte_address[i*2]&0x00000040) >> 6),(pte_address[i*2] & 0x3f), |
363 |
|
|
((pte_address[i*2+1]&0xfffff000) >> 12),((pte_address[i*2+1]&0x00000100) >> 8), |
364 |
|
|
((pte_address[i*2+1]&0x00000080) >> 7),((pte_address[i*2+1]&0x00000078) >> 3), |
365 |
|
|
(pte_address[i*2+1]&0x00000003))); |
366 |
|
|
vsid = (pte_address[i*2]&0x7fffff80) >> 7; |
367 |
|
|
ra0 = (uint32)pe[0].address & 0xfffff000; |
368 |
|
|
} |
369 |
|
|
if ((uint32)pe[0].size == B_PAGE_SIZE) { |
370 |
|
|
if (((uint32)pe[1].address & 0xfffff000)==(pte_address[i*2+1]&0xfffff000)) { |
371 |
|
|
D(bug("Found page 1f PtePos %04x V%x VSID %03x H%x API %02x RPN %03x R%1x C%1x WIMG%1x PP%1x \n", |
372 |
|
|
i << 2, |
373 |
|
|
((pte_address[i*2]&0x80000000) >> 31), ((pte_address[i*2]&0x7fffff80) >> 7), |
374 |
|
|
((pte_address[i*2]&0x00000040) >> 6), (pte_address[i*2] & 0x3f), |
375 |
|
|
((pte_address[i*2+1]&0xfffff000) >> 12), ((pte_address[i*2+1]&0x00000100) >> 8), |
376 |
|
|
((pte_address[i*2+1]&0x00000080) >> 7), ((pte_address[i*2+1]&0x00000078) >> 3), |
377 |
|
|
(pte_address[i*2+1]&0x00000003))); |
378 |
|
|
ra1 = (uint32)pe[1].address & 0xfffff000; |
379 |
|
|
} |
380 |
|
|
} else { |
381 |
|
|
if ((((uint32)pe[0].address + B_PAGE_SIZE) & 0xfffff000)==(pte_address[i*2+1]&0xfffff000)) { |
382 |
|
|
D(bug("Found page 1d PtePos %04x V%x VSID %03x H%x API %02x RPN %03x R%1x C%1x WIMG%1x PP%1x \n", |
383 |
|
|
i << 2, |
384 |
|
|
((pte_address[i*2]&0x80000000) >> 31), ((pte_address[i*2]&0x7fffff80) >> 7), |
385 |
|
|
((pte_address[i*2]&0x00000040) >> 6), (pte_address[i*2] & 0x3f), |
386 |
|
|
((pte_address[i*2+1]&0xfffff000) >> 12), ((pte_address[i*2+1]&0x00000100) >> 8), |
387 |
|
|
((pte_address[i*2+1]&0x00000080) >> 7), ((pte_address[i*2+1]&0x00000078) >> 3), |
388 |
|
|
(pte_address[i*2+1]&0x00000003))); |
389 |
|
|
ra1 = ((uint32)pe[0].address + B_PAGE_SIZE) & 0xfffff000; |
390 |
|
|
} |
391 |
|
|
} |
392 |
|
|
} |
393 |
|
|
|
394 |
|
|
// Map low memory for emulator |
395 |
|
|
free_pte_0 = NULL; |
396 |
|
|
free_pte_1 = NULL; |
397 |
|
|
__sync(); |
398 |
|
|
__isync(); |
399 |
|
|
inval_tlb(0); |
400 |
|
|
inval_tlb(B_PAGE_SIZE); |
401 |
|
|
if (sysinfo.cpu_type != B_CPU_PPC_603 && sysinfo.cpu_type != B_CPU_PPC_603e) |
402 |
|
|
tlbsync(); |
403 |
|
|
res = map_page(0, ra0, &free_pte_0, 0x12); |
404 |
|
|
if (res == B_NO_ERROR) |
405 |
|
|
res = map_page(B_PAGE_SIZE, ra1, &free_pte_1, 0x12); |
406 |
|
|
inval_tlb(0); |
407 |
|
|
inval_tlb(B_PAGE_SIZE); |
408 |
|
|
if (sysinfo.cpu_type != B_CPU_PPC_603 && sysinfo.cpu_type != B_CPU_PPC_603e) |
409 |
|
|
tlbsync(); |
410 |
|
|
__sync(); |
411 |
|
|
__isync(); |
412 |
|
|
|
413 |
|
|
// Restore interrupts |
414 |
|
|
restore_interrupts(cpu_st); |
415 |
|
|
|
416 |
|
|
// Create port so we know that messing was successful |
417 |
|
|
set_port_owner(create_port(1, PORT_NAME), B_SYSTEM_TEAM); |
418 |
|
|
return B_NO_ERROR; |
419 |
|
|
|
420 |
|
|
case SHEEP_DOWN: |
421 |
|
|
return B_NO_ERROR; |
422 |
|
|
|
423 |
|
|
default: |
424 |
|
|
return B_BAD_VALUE; |
425 |
|
|
} |
426 |
|
|
} |
427 |
|
|
|
428 |
|
|
|
429 |
|
|
/* |
430 |
|
|
* sheep_read - hook function for the read call |
431 |
|
|
*/ |
432 |
|
|
|
433 |
|
|
static status_t sheep_read(void *cookie, off_t pos, void *data, size_t *len) |
434 |
|
|
{ |
435 |
|
|
void *rom_adr; |
436 |
|
|
area_id area; |
437 |
|
|
system_info info; |
438 |
|
|
|
439 |
|
|
D(bug("read() pos %Lx, data %p, len %08x\n", pos, data, *len)); |
440 |
|
|
|
441 |
|
|
get_system_info(&info); |
442 |
|
|
if (info.platform_type == B_BEBOX_PLATFORM) { |
443 |
|
|
*len = 0; |
444 |
|
|
return B_ERROR; |
445 |
|
|
} |
446 |
|
|
if (*len != 0x400000 && pos != 0) { |
447 |
|
|
*len = 0; |
448 |
|
|
return B_BAD_VALUE; |
449 |
|
|
} |
450 |
|
|
area = map_physical_memory("mac_rom", (void *)0xff000000, 0x00400000, B_ANY_KERNEL_ADDRESS, B_READ_AREA, &rom_adr); |
451 |
|
|
D(bug("Mapped ROM to %p, area id %d\n", rom_adr, area)); |
452 |
|
|
if (area < 0) { |
453 |
|
|
*len = 0; |
454 |
|
|
return area; |
455 |
|
|
} |
456 |
|
|
D(bug("Copying ROM\n")); |
457 |
|
|
memcpy(data, rom_adr, *len); |
458 |
|
|
D(bug("Deleting area\n")); |
459 |
|
|
delete_area(area); |
460 |
|
|
return B_NO_ERROR; |
461 |
|
|
} |
462 |
|
|
|
463 |
|
|
|
464 |
|
|
/* |
465 |
|
|
* sheep_write - hook function for the write call |
466 |
|
|
*/ |
467 |
|
|
|
468 |
|
|
static status_t sheep_write(void *cookie, off_t pos, const void *data, size_t *len) |
469 |
|
|
{ |
470 |
|
|
D(bug("write() pos %Lx, data %p, len %08x\n", pos, data, *len)); |
471 |
|
|
return B_READ_ONLY_DEVICE; |
472 |
|
|
} |