Update and reformat copyright, remove trailing white spaces and send
[kopensolaris-gnu/glibc.git] / sysdeps / standalone / i386 / i386.h
1 /* Copyright (C) 1994, 1997 Free Software Foundation, Inc.
2    Contributed by Joel Sherrill (jsherril@redstone-emh2.army.mil),
3      On-Line Applications Research Corporation.
4    This file is part of the GNU C Library.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 /*  i386.h
22  *
23  *  This file contains macros which are used to access i80386
24  *  registers which are not addressable by C.  This file contains
25  *  functions which are useful to those developing target
26  *  specific support routines.
27  */
28
29 #ifndef i386_h__
30 #define i386_h__
31
32 typedef unsigned char   unsigned8;
33 typedef unsigned short  unsigned16;
34 typedef unsigned int    unsigned32;
35
36 #define disable_intr( isrlevel ) \
37   { (isrlevel) = 0; \
38     asm volatile ( "pushf ; \
39                     pop  %0 ; \
40                     cli   " \
41                     : "=r" ((isrlevel)) : "0" ((isrlevel)) ); \
42   }
43
44
45 #define enable_intr( isrlevel ) \
46   { asm volatile ( "push %0 ; \
47                     popf " \
48                     : "=r" ((isrlevel)) : "0" ((isrlevel)) ); \
49   }
50
51 #define delay( _microseconds ) \
52   { \
53     unsigned32 _counter; \
54     \
55     _counter = (_microseconds); \
56     \
57     asm volatile ( "0: nop;" \
58                    " mov %0,%0 ;" \
59                    " loop 0" : "=c" (_counter) \
60                                       : "0"  (_counter) \
61                  ); \
62     \
63   }
64
65 /* segment access functions */
66
67 static inline unsigned16 get_cs()
68 {
69   register unsigned16 segment = 0;
70
71   asm volatile ( "movw %%cs,%0" : "=r" (segment) : "0" (segment) );
72
73   return segment;
74 }
75
76 static inline unsigned16 get_ds()
77 {
78   register unsigned16 segment = 0;
79
80   asm volatile ( "movw %%ds,%0" : "=r" (segment) : "0" (segment) );
81
82   return segment;
83 }
84
85 static inline unsigned16 get_es()
86 {
87   register unsigned16 segment = 0;
88
89   asm volatile ( "movw %%es,%0" : "=r" (segment) : "0" (segment) );
90
91   return segment;
92 }
93
94 static inline unsigned16 get_ss()
95 {
96   register unsigned16 segment = 0;
97
98   asm volatile ( "movw %%ss,%0" : "=r" (segment) : "0" (segment) );
99
100   return segment;
101 }
102
103 static inline unsigned16 get_fs()
104 {
105   register unsigned16 segment = 0;
106
107   asm volatile ( "movw %%fs,%0" : "=r" (segment) : "0" (segment) );
108
109   return segment;
110 }
111
112 static inline unsigned16 get_gs()
113 {
114   register unsigned16 segment = 0;
115
116   asm volatile ( "movw %%gs,%0" : "=r" (segment) : "0" (segment) );
117
118   return segment;
119 }
120
121 /* i80x86 I/O instructions */
122
123 #define outport_byte( _port, _value ) \
124    { register unsigned16 __port  = _port; \
125      register unsigned8  __value = _value; \
126      \
127      asm volatile ( "outb %0,%1" : "=a" (__value), "=d" (__port) \
128                                  : "0"   (__value), "1"  (__port) \
129                   ); \
130    }
131
132 #define outport_word( _port, _value ) \
133    { register unsigned16 __port  = _port; \
134      register unsigned16 __value = _value; \
135      \
136      asm volatile ( "outw %0,%1" : "=a" (__value), "=d" (__port) \
137                                  : "0"   (__value), "1"  (__port) \
138                   ); \
139    }
140
141 #define outport_long( _port, _value ) \
142    { register unsigned16 __port  = _port; \
143      register unsigned32 __value = _value; \
144      \
145      asm volatile ( "outl %0,%1" : "=a" (__value), "=d" (__port) \
146                                  : "0"   (__value), "1"  (__port) \
147                   ); \
148    }
149
150 #define inport_byte( _port, _value ) \
151    { register unsigned16 __port  = _port; \
152      register unsigned8  __value = 0; \
153      \
154      asm volatile ( "inb %1,%0" : "=a" (__value), "=d" (__port) \
155                                 : "0"   (__value), "1"  (__port) \
156                   ); \
157      _value = __value; \
158    }
159
160 #define inport_word( _port, _value ) \
161    { register unsigned16 __port  = _port; \
162      register unsigned16 __value = 0; \
163      \
164      asm volatile ( "inw %1,%0" : "=a" (__value), "=d" (__port) \
165                                 : "0"   (__value), "1"  (__port) \
166                   ); \
167      _value = __value; \
168    }
169
170 #define inport_long( _port, _value ) \
171    { register unsigned16 __port  = _port; \
172      register unsigned32 __value = 0; \
173      \
174      asm volatile ( "inl %1,%0" : "=a" (__value), "=d" (__port) \
175                                 : "0"   (__value), "1"  (__port) \
176                   ); \
177      _value = __value; \
178    }
179
180 /* structures */
181
182 /* See Chapter 5 - Memory Management in i386 manual */
183
184 struct GDT_slot {
185   unsigned16 limit_0_15;
186   unsigned16 base_0_15;
187   unsigned8  base_16_23;
188   unsigned8  type_dt_dpl_p;
189   unsigned8  limit_16_19_granularity;
190   unsigned8  base_24_31;
191 };
192
193 /* See Chapter 9 - Exceptions and Interrupts in i386 manual
194  *
195  *  NOTE: This is the IDT entry for interrupt gates ONLY.
196  */
197
198 struct IDT_slot {
199   unsigned16 offset_0_15;
200   unsigned16 segment_selector;
201   unsigned8  reserved;
202   unsigned8  p_dpl;
203   unsigned16 offset_16_31;
204 };
205
206 struct DTR_load_save_format {
207   unsigned16 limit;
208   unsigned32 physical_address;
209 };
210
211 /* variables */
212
213 extern struct IDT_slot Interrupt_descriptor_table[ 256 ];
214 extern struct GDT_slot Global_descriptor_table[ 8192 ];
215
216 /* functions */
217
218 #ifdef CPU_INITIALIZE
219 #define EXTERN
220 #else
221 #undef EXTERN
222 #define EXTERN extern
223 #endif
224
225 void *Logical_to_physical(
226   unsigned16  segment,
227   void             *address
228 );
229
230 void *Physical_to_logical(
231   unsigned16  segment,
232   void             *address
233 );
234
235 /* complicated static inline functions */
236
237 #define get_GDTR( _gdtr_address ) \
238   { \
239     void                        *_gdtr = (_gdtr_address); \
240     \
241     asm volatile( "sgdt   (%0)" : "=r" (_gdtr) : "0" (_gdtr) ); \
242   }
243
244 #define get_GDT_slot( _gdtr_base, _segment, _slot_address ) \
245   { \
246     register unsigned32  _gdt_slot  = (_gdtr_base) + (_segment); \
247     register volatile void    *_slot      = (_slot_address); \
248     register unsigned32  _temporary = 0; \
249     \
250     asm volatile( "movl %%gs:(%0),%1 ; \
251                    movl %1,(%2) ; \
252                    movl %%gs:4(%0),%1 ; \
253                    movl %1,4(%2)"  \
254                      : "=r" (_gdt_slot), "=r" (_temporary), "=r" (_slot) \
255                      : "0"  (_gdt_slot), "1"  (_temporary), "2"  (_slot) \
256                 );  \
257   }
258
259 #define set_GDT_slot( _gdtr_base, _segment, _slot_address ) \
260   { \
261     register unsigned32  _gdt_slot  = (_gdtr_base) + (_segment); \
262     register volatile void    *_slot      = (_slot_address); \
263     register unsigned32  _temporary = 0; \
264     \
265     asm volatile( "movl (%2),%1 ; \
266                    movl %1,%%gs:(%0) ; \
267                    movl 4(%2),%1 ; \
268                    movl %1,%%gs:4(%0) \
269                   " \
270                      : "=r" (_gdt_slot), "=r" (_temporary), "=r" (_slot) \
271                      : "0"  (_gdt_slot), "1"  (_temporary), "2"  (_slot) \
272                 );  \
273   }
274
275 static inline void set_segment(
276   unsigned16 segment,
277   unsigned32 base,
278   unsigned32 limit
279 )
280 {
281   struct DTR_load_save_format  gdtr;
282   volatile struct GDT_slot     Gdt_slot;
283   volatile struct GDT_slot    *gdt_slot = &Gdt_slot;
284   unsigned16             tmp_segment = 0;
285   unsigned32             limit_adjusted;
286
287
288   /* load physical address of the GDT */
289
290   get_GDTR( &gdtr );
291
292   gdt_slot->type_dt_dpl_p  = 0x92;             /* present, dpl=0,      */
293                                                /* application=1,       */
294                                                /* type=data read/write */
295   gdt_slot->limit_16_19_granularity = 0x40;    /* 32 bit segment       */
296
297   limit_adjusted = limit;
298   if ( limit > 4095 ) {
299     gdt_slot->limit_16_19_granularity |= 0x80; /* set granularity bit */
300     limit_adjusted /= 4096;
301   }
302
303   gdt_slot->limit_16_19_granularity |= (limit_adjusted >> 16) & 0xff;
304   gdt_slot->limit_0_15               = limit_adjusted & 0xffff;
305
306   gdt_slot->base_0_15  = base & 0xffff;
307   gdt_slot->base_16_23 = (base >> 16) & 0xff;
308   gdt_slot->base_24_31 = (base >> 24);
309
310   set_GDT_slot( gdtr.physical_address, segment, gdt_slot );
311
312   /* Now, reload all segment registers so the limit takes effect. */
313
314   asm volatile( "movw %%ds,%0 ; movw %0,%%ds
315                  movw %%es,%0 ; movw %0,%%es
316                  movw %%fs,%0 ; movw %0,%%fs
317                  movw %%gs,%0 ; movw %0,%%gs
318                  movw %%ss,%0 ; movw %0,%%ss"
319                    : "=r" (tmp_segment)
320                    : "0"  (tmp_segment)
321               );
322
323 }
324
325 #endif
326 /* end of include file */