Annotation of sys/arch/m68k/060sp/os.s, Revision 1.1.1.1
1.1 nbrk 1: #
2: # $OpenBSD: os.s,v 1.2 1996/05/30 22:15:04 niklas Exp $
3: # $NetBSD: os.s,v 1.2 1996/05/15 19:49:06 is Exp $
4: #
5:
6: #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7: # MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
8: # M68000 Hi-Performance Microprocessor Division
9: # M68060 Software Package Production Release
10: #
11: # M68060 Software Package Copyright (C) 1993, 1994, 1995, 1996 Motorola Inc.
12: # All rights reserved.
13: #
14: # THE SOFTWARE is provided on an "AS IS" basis and without warranty.
15: # To the maximum extent permitted by applicable law,
16: # MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
17: # INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS
18: # FOR A PARTICULAR PURPOSE and any warranty against infringement with
19: # regard to the SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF)
20: # and any accompanying written materials.
21: #
22: # To the maximum extent permitted by applicable law,
23: # IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
24: # (INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
25: # BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
26: # ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
27: #
28: # Motorola assumes no responsibility for the maintenance and support
29: # of the SOFTWARE.
30: #
31: # You are hereby granted a copyright license to use, modify, and distribute the
32: # SOFTWARE so long as this entire notice is retained without alteration
33: # in any modified and/or redistributed versions, and that such modified
34: # versions are clearly identified as such.
35: # No licenses are granted by implication, estoppel or otherwise under any
36: # patents or trademarks of Motorola, Inc.
37: #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
38:
39: #
40: # os.s
41: #
42: # This file contains:
43: # - example "Call-Out"s required by both the ISP and FPSP.
44: #
45:
46:
47: #################################
48: # EXAMPLE CALL-OUTS #
49: # #
50: # _060_dmem_write() #
51: # _060_dmem_read() #
52: # _060_imem_read() #
53: # _060_dmem_read_byte() #
54: # _060_dmem_read_word() #
55: # _060_dmem_read_long() #
56: # _060_imem_read_word() #
57: # _060_imem_read_long() #
58: # _060_dmem_write_byte() #
59: # _060_dmem_write_word() #
60: # _060_dmem_write_long() #
61: # #
62: # _060_real_trace() #
63: # _060_real_access() #
64: #################################
65:
66: #
67: # Each IO routine checks to see if the memory write/read is to/from user
68: # or supervisor application space. The examples below use simple "move"
69: # instructions for supervisor mode applications and call _copyin()/_copyout()
70: # for user mode applications.
71: # When installing the 060SP, the _copyin()/_copyout() equivalents for a
72: # given operating system should be substituted.
73: #
74: # The addresses within the 060SP are guaranteed to be on the stack.
75: # The result is that Unix processes are allowed to sleep as a consequence
76: # of a page fault during a _copyout.
77: #
78:
79: #
80: # _060_dmem_write():
81: #
82: # Writes to data memory while in supervisor mode.
83: #
84: # INPUTS:
85: # a0 - supervisor source address
86: # a1 - user destination address
87: # d0 - number of bytes to write
88: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
89: # OUTPUTS:
90: # d1 - 0 = success, !0 = failure
91: #
92: global _060_dmem_write
93: _060_dmem_write:
94: btst &0x5,0x4(%a6) # check for supervisor state
95: beq.b user_write
96: super_write:
97: mov.b (%a0)+,(%a1)+ # copy 1 byte
98: subq.l &0x1,%d0 # decr byte counter
99: bne.b super_write # quit if ctr = 0
100: clr.l %d1 # return success
101: rts
102: user_write:
103: mov.l %d0,-(%sp) # pass: counter
104: mov.l %a1,-(%sp) # pass: user dst
105: mov.l %a0,-(%sp) # pass: supervisor src
106: bsr.l _copyout # write byte to user mem
107: mov.l %d0,%d1 # return success
108: add.l &0xc, %sp # clear 3 lw params
109: rts
110:
111: #
112: # _060_imem_read(), _060_dmem_read():
113: #
114: # Reads from data/instruction memory while in supervisor mode.
115: #
116: # INPUTS:
117: # a0 - user source address
118: # a1 - supervisor destination address
119: # d0 - number of bytes to read
120: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
121: # OUTPUTS:
122: # d1 - 0 = success, !0 = failure
123: #
124: global _060_imem_read
125: global _060_dmem_read
126: _060_imem_read:
127: _060_dmem_read:
128: btst &0x5,0x4(%a6) # check for supervisor state
129: beq.b user_read
130: super_read:
131: mov.b (%a0)+,(%a1)+ # copy 1 byte
132: subq.l &0x1,%d0 # decr byte counter
133: bne.b super_read # quit if ctr = 0
134: clr.l %d1 # return success
135: rts
136: user_read:
137: mov.l %d0,-(%sp) # pass: counter
138: mov.l %a1,-(%sp) # pass: super dst
139: mov.l %a0,-(%sp) # pass: user src
140: bsr.l _copyin # read byte from user mem
141: mov.l %d0,%d1 # return success
142: add.l &0xc,%sp # clear 3 lw params
143: rts
144:
145: #
146: # _060_dmem_read_byte():
147: #
148: # Read a data byte from user memory.
149: #
150: # INPUTS:
151: # a0 - user source address
152: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
153: # OUTPUTS:
154: # d0 - data byte in d0
155: # d1 - 0 = success, !0 = failure
156: #
157: global _060_dmem_read_byte
158: _060_dmem_read_byte:
159: btst &0x5,0x4(%a6) # check for supervisor state
160: bne.b dmrbs # supervisor
161: dmrbu: clr.l -(%sp) # clear space on stack for result
162: mov.l &0x1,-(%sp) # pass: # bytes to copy
163: pea 0x7(%sp) # pass: dst addr (stack)
164: mov.l %a0,-(%sp) # pass: src addr (user mem)
165: bsr.l _copyin # "copy in" the data
166: mov.l %d0,%d1 # return success
167: add.l &0xc,%sp # delete params
168: mov.l (%sp)+,%d0 # put answer in d0
169: rts
170: dmrbs: clr.l %d0 # clear whole longword
171: mov.b (%a0),%d0 # fetch super byte
172: clr.l %d1 # return success
173: rts
174:
175: #
176: # _060_dmem_read_word():
177: #
178: # Read a data word from user memory.
179: #
180: # INPUTS:
181: # a0 - user source address
182: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
183: # OUTPUTS:
184: # d0 - data word in d0
185: # d1 - 0 = success, !0 = failure
186: #
187: global _060_dmem_read_word
188: _060_dmem_read_word:
189: btst &0x5,0x4(%a6) # check for supervisor state
190: bne.b dmrws # supervisor
191: dmrwu: clr.l -(%sp) # clear space on stack for result
192: mov.l &0x2,-(%sp) # pass: # bytes to copy
193: pea 0x6(%sp) # pass: dst addr (stack)
194: mov.l %a0,-(%sp) # pass: src addr (user mem)
195: bsr.l _copyin # "copy in" the data
196: mov.l %d0,%d1 # return success
197: add.l &0xc,%sp # delete params
198: mov.l (%sp)+,%d0 # put answer in d0
199: rts
200: dmrws: clr.l %d0 # clear whole longword
201: mov.w (%a0), %d0 # fetch super word
202: clr.l %d1 # return success
203: rts
204:
205: #
206: # _060_dmem_read_long():
207: #
208:
209: #
210: # INPUTS:
211: # a0 - user source address
212: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
213: # OUTPUTS:
214: # d0 - data longword in d0
215: # d1 - 0 = success, !0 = failure
216: #
217: global _060_dmem_read_long
218: _060_dmem_read_long:
219: btst &0x5,0x4(%a6) # check for supervisor state
220: bne.b dmrls # supervisor
221: dmrlu: subq.l &0x4,%sp # clear space on stack for result
222: mov.l &0x4,-(%sp) # pass: # bytes to copy
223: pea 0x4(%sp) # pass: dst addr (stack)
224: mov.l %a0,-(%sp) # pass: src addr (user mem)
225: bsr.l _copyin # "copy in" the data
226: mov.l %d0,%d1 # return success
227: add.l &0xc,%sp # delete params
228: mov.l (%sp)+,%d0 # put answer in d0
229: rts
230: dmrls: mov.l (%a0),%d0 # fetch super longword
231: clr.l %d1 # return success
232: rts
233:
234: #
235: # _060_dmem_write_byte():
236: #
237: # Write a data byte to user memory.
238: #
239: # INPUTS:
240: # a0 - user destination address
241: # d0 - data byte in d0
242: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
243: # OUTPUTS:
244: # d1 - 0 = success, !0 = failure
245: #
246: global _060_dmem_write_byte
247: _060_dmem_write_byte:
248: btst &0x5,0x4(%a6) # check for supervisor state
249: bne.b dmwbs # supervisor
250: dmwbu: mov.l %d0,-(%sp) # put src on stack
251: mov.l &0x1,-(%sp) # pass: # bytes to copy
252: mov.l %a0,-(%sp) # pass: dst addr (user mem)
253: pea 0xb(%sp) # pass: src addr (stack)
254: bsr.l _copyout # "copy out" the data
255: mov.l %d0,%d1 # return success
256: add.l &0x10,%sp # delete params + src
257: rts
258: dmwbs: mov.b %d0,(%a0) # store super byte
259: clr.l %d1 # return success
260: rts
261:
262: #
263: # _060_dmem_write_word():
264: #
265: # Write a data word to user memory.
266: #
267: # INPUTS:
268: # a0 - user destination address
269: # d0 - data word in d0
270: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
271: # OUTPUTS:
272: # d1 - 0 = success, !0 = failure
273: #
274: global _060_dmem_write_word
275: _060_dmem_write_word:
276: btst &0x5,0x4(%a6) # check for supervisor state
277: bne.b dmwws # supervisor
278: dmwwu: mov.l %d0,-(%sp) # put src on stack
279: mov.l &0x2,-(%sp) # pass: # bytes to copy
280: mov.l %a0,-(%sp) # pass: dst addr (user mem)
281: pea 0xa(%sp) # pass: src addr (stack)
282: bsr.l _copyout # "copy out" the data
283: mov.l %d0,%d1 # return success
284: add.l &0x10,%sp # delete params + src
285: rts
286: dmwws: mov.w %d0,(%a0) # store super word
287: clr.l %d1 # return success
288: rts
289:
290: #
291: # _060_dmem_write_long():
292: #
293: # Write a data longword to user memory.
294: #
295: # INPUTS:
296: # a0 - user destination address
297: # d0 - data longword in d0
298: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
299: # OUTPUTS:
300: # d1 - 0 = success, !0 = failure
301: #
302: global _060_dmem_write_long
303: _060_dmem_write_long:
304: btst &0x5,0x4(%a6) # check for supervisor state
305: bne.b dmwls # supervisor
306: dmwlu: mov.l %d0,-(%sp) # put src on stack
307: mov.l &0x4,-(%sp) # pass: # bytes to copy
308: mov.l %a0,-(%sp) # pass: dst addr (user mem)
309: pea 0x8(%sp) # pass: src addr (stack)
310: bsr.l _copyout # "copy out" the data
311: mov.l %d0,%d1 # return success
312: add.l &0x10,%sp # delete params + src
313: rts
314: dmwls: mov.l %d0,(%a0) # store super longword
315: clr.l %d1 # return success
316: rts
317:
318: #
319: # _060_imem_read_word():
320: #
321: # Read an instruction word from user memory.
322: #
323: # INPUTS:
324: # a0 - user source address
325: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
326: # OUTPUTS:
327: # d0 - instruction word in d0
328: # d1 - 0 = success, !0 = failure
329: #
330: global _060_imem_read_word
331: _060_imem_read_word:
332: btst &0x5,0x4(%a6) # check for supervisor state
333: bne.b imrws # supervisor
334: imrwu: clr.l -(%sp) # clear space on stack for result
335: mov.l &0x2,-(%sp) # pass: # bytes to copy
336: pea 0x6(%sp) # pass: dst addr (stack)
337: mov.l %a0,-(%sp) # pass: src addr (user mem)
338: bsr.l _copyin # "copy in" the data
339: mov.l %d0,%d1 # return success
340: add.l &0xc,%sp # delete params
341: mov.l (%sp)+,%d0 # put answer in d0
342: rts
343: imrws: mov.w (%a0),%d0 # fetch super word
344: clr.l %d1 # return success
345: rts
346:
347: #
348: # _060_imem_read_long():
349: #
350: # Read an instruction longword from user memory.
351: #
352: # INPUTS:
353: # a0 - user source address
354: # 0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
355: # OUTPUTS:
356: # d0 - instruction longword in d0
357: # d1 - 0 = success, !0 = failure
358: #
359: global _060_imem_read_long
360: _060_imem_read_long:
361: btst &0x5,0x4(%a6) # check for supervisor state
362: bne.b imrls # supervisor
363: imrlu: subq.l &0x4,%sp # clear space on stack for result
364: mov.l &0x4,-(%sp) # pass: # bytes to copy
365: pea 0x4(%sp) # pass: dst addr (stack)
366: mov.l %a0,-(%sp) # pass: src addr (user mem)
367: bsr.l _copyin # "copy in" the data
368: mov.l %d0,%d1 # return success
369: add.l &0xc,%sp # delete params
370: mov.l (%sp)+,%d0 # put answer in d0
371: rts
372: imrls: mov.l (%a0),%d0 # fetch super longword
373: clr.l %d1 # return success
374: rts
375:
376: ################################################
377:
378: #
379: # Use these routines if your kernel doesn't have _copyout/_copyin equivalents.
380: # Assumes that D0/D1/A0/A1 are scratch registers. The _copyin/_copyout
381: # below assume that the SFC/DFC have been set previously.
382: #
383:
384: #
385: # int _copyout(supervisor_addr, user_addr, nbytes)
386: #
387: global _copyout
388: _copyout:
389: mov.l 4(%sp),%a0 # source
390: mov.l 8(%sp),%a1 # destination
391: mov.l 12(%sp),%d0 # count
392: moreout:
393: mov.b (%a0)+,%d1 # fetch supervisor byte
394: movs.b %d1,(%a1)+ # store user byte
395: subq.l &0x1,%d0 # are we through yet?
396: bne.w moreout # no; so, continue
397: rts
398:
399: #
400: # int _copyin(user_addr, supervisor_addr, nbytes)
401: #
402: global _copyin
403: _copyin:
404: mov.l 4(%sp),%a0 # source
405: mov.l 8(%sp),%a1 # destination
406: mov.l 12(%sp),%d0 # count
407: morein:
408: movs.b (%a0)+,%d1 # fetch user byte
409: mov.b %d1,(%a1)+ # write supervisor byte
410: subq.l &0x1,%d0 # are we through yet?
411: bne.w morein # no; so, continue
412: rts
413:
414: ############################################################################
415:
416: #
417: # _060_real_trace():
418: #
419: # This is the exit point for the 060FPSP when an instruction is being traced
420: # and there are no other higher priority exceptions pending for this instruction
421: # or they have already been processed.
422: #
423: # The sample code below simply executes an "rte".
424: #
425: global _060_real_trace
426: _060_real_trace:
427: rte
428:
429: #
430: # _060_real_access():
431: #
432: # This is the exit point for the 060FPSP when an access error exception
433: # is encountered. The routine below should point to the operating system
434: # handler for access error exceptions. The exception stack frame is an
435: # 8-word access error frame.
436: #
437: # The sample routine below simply executes an "rte" instruction which
438: # is most likely the incorrect thing to do and could put the system
439: # into an infinite loop.
440: #
441: global _060_real_access
442: _060_real_access:
443: rte
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to os.s CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / m68k / 060sp