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 Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the 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    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    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\n"
 315                 "movw %%es,%0 ; movw %0,%%es\n"
 316                 "movw %%fs,%0 ; movw %0,%%fs\n"
 317                 "movw %%gs,%0 ; movw %0,%%gs\n"
 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 */