Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
2 | MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP | |
3 | M68000 Hi-Performance Microprocessor Division | |
4 | M68060 Software Package | |
5 | Production Release P1.00 -- October 10, 1994 | |
6 | ||
96de0e25 | 7 | M68060 Software Package Copyright © 1993, 1994 Motorola Inc. All rights reserved. |
1da177e4 LT |
8 | |
9 | THE SOFTWARE is provided on an "AS IS" basis and without warranty. | |
10 | To the maximum extent permitted by applicable law, | |
11 | MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, | |
12 | INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE | |
13 | and any warranty against infringement with regard to the SOFTWARE | |
14 | (INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials. | |
15 | ||
16 | To the maximum extent permitted by applicable law, | |
17 | IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER | |
18 | (INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, | |
19 | BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) | |
20 | ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE. | |
21 | Motorola assumes no responsibility for the maintenance and support of the SOFTWARE. | |
22 | ||
23 | You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE | |
24 | so long as this entire notice is retained without alteration in any modified and/or | |
25 | redistributed versions, and that such modified versions are clearly identified as such. | |
26 | No licenses are granted by implication, estoppel or otherwise under any patents | |
27 | or trademarks of Motorola, Inc. | |
28 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
29 | 68060 INTEGER SOFTWARE PACKAGE (Kernel version) | |
30 | ------------------------------------------------ | |
31 | ||
32 | The file isp.sa contains the 68060 Integer Software Package. | |
33 | This package is essentially an exception handler that can be | |
34 | integrated into an operating system to handle the "Unimplemented | |
35 | Integer Instruction" exception vector #61. | |
36 | This exception is taken when any of the integer instructions | |
37 | not hardware implemented on the 68060 are encountered. The | |
38 | isp.sa provides full emulation support for these instructions. | |
39 | ||
40 | The unimplemented integer instructions are: | |
41 | 64-bit divide | |
42 | 64-bit multiply | |
43 | movep | |
44 | cmp2 | |
45 | chk2 | |
46 | cas (w/ a misaligned effective address) | |
47 | cas2 | |
48 | ||
49 | Release file format: | |
50 | -------------------- | |
51 | The file isp.sa is essentially a hexadecimal image of the | |
52 | release package. This is the ONLY format which will be supported. | |
53 | The hex image was created by assembling the source code and | |
54 | then converting the resulting binary output image into an | |
55 | ASCII text file. The hexadecimal numbers are listed | |
56 | using the Motorola Assembly Syntax assembler directive "dc.l" | |
57 | (define constant longword). The file can be converted to other | |
58 | assembly syntaxes by using any word processor with a global | |
59 | search and replace function. | |
60 | ||
61 | To assist in assembling and linking this module with other modules, | |
62 | the installer should add a symbolic label to the top of the file. | |
63 | This will allow calling routines to access the entry points | |
64 | of this package. | |
65 | ||
66 | The source code isp.s has also been included but only for | |
67 | documentation purposes. | |
68 | ||
69 | Release file structure: | |
70 | ----------------------- | |
71 | ||
72 | (top of module) | |
73 | ----------------- | |
74 | | | - 128 byte-sized section | |
75 | (1) | Call-Out | - 4 bytes per entry (user fills these in) | |
76 | | | - example routines in iskeleton.s | |
77 | ----------------- | |
78 | | | - 8 bytes per entry | |
79 | (2) | Entry Point | - user does a "bra" or "jmp" to this address | |
80 | | | | |
81 | ----------------- | |
82 | | | - code section | |
83 | (3) ~ ~ | |
84 | | | | |
85 | ----------------- | |
86 | (bottom of module) | |
87 | ||
88 | The first section of this module is the "Call-out" section. This section | |
89 | is NOT INCLUDED in isp.sa (an example "Call-out" section is provided at | |
90 | the end of the file iskeleton.s). The purpose of this section is to allow | |
91 | the ISP routines to reference external functions that must be provided | |
92 | by the host operating system. This section MUST be exactly 128 bytes in | |
93 | size. There are 32 fields, each 4 bytes in size. Each field corresponds | |
94 | to a function required by the ISP (these functions and their location are | |
95 | listed in "68060ISP call-outs" below). Each field entry should contain | |
96 | the address of the corresponding function RELATIVE to the starting address | |
97 | of the "call-out" section. The "Call-out" section must sit adjacent to the | |
98 | isp.sa image in memory. | |
99 | ||
100 | The second section, the "Entry-point" section, is used by external routines | |
101 | to access the functions within the ISP. Since the isp.sa hex file contains | |
102 | no symbol names, this section contains function entry points that are fixed | |
103 | with respect to the top of the package. The currently defined entry-points | |
104 | are listed in section "68060 ISP entry points" below. A calling routine | |
105 | would simply execute a "bra" or "jmp" that jumped to the selected function | |
106 | entry-point. | |
107 | ||
108 | For example, if the 68060 hardware took a "Unimplemented Integer Instruction" | |
109 | exception (vector #61), the operating system should execute something | |
110 | similar to: | |
111 | ||
112 | bra _060ISP_TOP+128+0 | |
113 | ||
114 | (_060ISP_TOP is the starting address of the "Call-out" section; the "Call-out" | |
115 | section is 128 bytes long; and the Unimplemented Integer ISP handler entry | |
116 | point is located 0 bytes from the top of the "Entry-point" section.) | |
117 | ||
118 | The third section is the code section. After entering through an "Entry-point", | |
119 | the entry code jumps to the appropriate emulation code within the code section. | |
120 | ||
121 | 68060ISP call-outs: (details in iskeleton.s) | |
122 | -------------------- | |
123 | 0x000: _060_real_chk | |
124 | 0x004: _060_real_divbyzero | |
125 | 0x008: _060_real_trace | |
126 | 0x00c: _060_real_access | |
127 | 0x010: _060_isp_done | |
128 | ||
129 | 0x014: _060_real_cas | |
130 | 0x018: _060_real_cas2 | |
131 | 0x01c: _060_real_lock_page | |
132 | 0x020: _060_real_unlock_page | |
133 | ||
134 | 0x024: (Motorola reserved) | |
135 | 0x028: (Motorola reserved) | |
136 | 0x02c: (Motorola reserved) | |
137 | 0x030: (Motorola reserved) | |
138 | 0x034: (Motorola reserved) | |
139 | 0x038: (Motorola reserved) | |
140 | 0x03c: (Motorola reserved) | |
141 | ||
142 | 0x040: _060_imem_read | |
143 | 0x044: _060_dmem_read | |
144 | 0x048: _060_dmem_write | |
145 | 0x04c: _060_imem_read_word | |
146 | 0x050: _060_imem_read_long | |
147 | 0x054: _060_dmem_read_byte | |
148 | 0x058: _060_dmem_read_word | |
149 | 0x05c: _060_dmem_read_long | |
150 | 0x060: _060_dmem_write_byte | |
151 | 0x064: _060_dmem_write_word | |
152 | 0x068: _060_dmem_write_long | |
153 | ||
154 | 0x06c: (Motorola reserved) | |
155 | 0x070: (Motorola reserved) | |
156 | 0x074: (Motorola reserved) | |
157 | 0x078: (Motorola reserved) | |
158 | 0x07c: (Motorola reserved) | |
159 | ||
160 | 68060ISP entry points: | |
161 | ----------------------- | |
162 | 0x000: _060_isp_unimp | |
163 | ||
164 | 0x008: _060_isp_cas | |
165 | 0x010: _060_isp_cas2 | |
166 | 0x018: _060_isp_cas_finish | |
167 | 0x020: _060_isp_cas2_finish | |
168 | 0x028: _060_isp_cas_inrange | |
169 | 0x030: _060_isp_cas_terminate | |
170 | 0x038: _060_isp_cas_restart | |
171 | ||
172 | Integrating cas/cas2: | |
173 | --------------------- | |
174 | The instructions "cas2" and "cas" (when used with a misaligned effective | |
175 | address) take the Unimplemented Integer Instruction exception. When the | |
176 | 060ISP is installed properly, these instructions will enter through the | |
177 | _060_isp_unimp() entry point of the ISP. | |
178 | ||
179 | After the 060ISP decodes the instruction type and fetches the appropriate | |
180 | data registers, and BEFORE the actual emulated transfers occur, the | |
181 | package calls either the "Call-out" _060_real_cas() or _060_real_cas2(). | |
182 | If the emulation code provided by the 060ISP is sufficient for the | |
183 | host system (see isp.s source code), then these "Call-out"s should be | |
184 | made, by the system integrator, to point directly back into the package | |
185 | through the "Entry-point"s _060_isp_cas() or _060_isp_cas2(). | |
186 | ||
187 | One other necessary action by the integrator is to supply the routines | |
188 | _060_real_lock_page() and _060_real_unlock_page(). These functions are | |
189 | defined further in iskeleton.s and the 68060 Software Package Specification. | |
190 | ||
191 | If the "core" emulation routines of either "cas" or "cas2" perform some | |
192 | actions which are too system-specific, then the system integrator must | |
193 | supply new emulation code. This new emulation code should reside within | |
194 | the functions _060_real_cas() or _060_real_cas2(). When this new emulation | |
195 | code has completed, then it should re-enter the 060ISP package through the | |
196 | "Entry-point" _060_isp_cas_finish() or _060_isp_cas2_finish(). | |
197 | To see what the register state is upon entering _060_real_cas() or | |
198 | _060_real_cas2() and what it should be upon return to the package through | |
199 | _060_isp_cas_finish() or _060_isp_cas2_finish(), please refer to the | |
200 | source code in isp.s. | |
201 | ||
202 | Miscellaneous: | |
203 | -------------- | |
204 | ||
205 | _060_isp_unimp: | |
206 | ---------------- | |
207 | - documented in 2.2 in spec. | |
208 | - Basic flow: | |
209 | exception taken ---> enter _060_isp_unimp --| | |
210 | | | |
211 | | | |
212 | may exit through _060_real_itrace <----| | |
213 | or | | |
214 | may exit through _060_real_chk <----| | |
215 | or | | |
216 | may exit through _060_real_divbyzero <----| | |
217 | or | | |
218 | may exit through _060_isp_done <----| |