drivers: delete unused header files

Signed-off-by: Masahiro Yamada <yamada.m@jp.panasonic.com>

3 files changed, 0 insertions, 1217 deletions

diff --git a/drivers/bios_emulator/include/x86emu/prim_asm.h b/drivers/bios_emulator/include/x86emu/prim_asm.h
deleted file mode 100644
index 4cb4cab..0000000
--- a/drivers/bios_emulator/include/x86emu/prim_asm.h
+++ /dev/null
@@ -1,970 +0,0 @@
-/****************************************************************************
-*
-*                       Realmode X86 Emulator Library
-*
-*               Copyright (C) 1991-2004 SciTech Software, Inc.
-*                    Copyright (C) David Mosberger-Tang
-*                      Copyright (C) 1999 Egbert Eich
-*
-*  ========================================================================
-*
-*  Permission to use, copy, modify, distribute, and sell this software and
-*  its documentation for any purpose is hereby granted without fee,
-*  provided that the above copyright notice appear in all copies and that
-*  both that copyright notice and this permission notice appear in
-*  supporting documentation, and that the name of the authors not be used
-*  in advertising or publicity pertaining to distribution of the software
-*  without specific, written prior permission.  The authors makes no
-*  representations about the suitability of this software for any purpose.
-*  It is provided "as is" without express or implied warranty.
-*
-*  THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
-*  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
-*  EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
-*  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
-*  USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-*  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-*  PERFORMANCE OF THIS SOFTWARE.
-*
-*  ========================================================================
-*
-* Language:     Watcom C++ 10.6 or later
-* Environment:  Any
-* Developer:    Kendall Bennett
-*
-* Description:  Inline assembler versions of the primitive operand
-*               functions for faster performance. At the moment this is
-*               x86 inline assembler, but these functions could be replaced
-*               with native inline assembler for each supported processor
-*               platform.
-*
-****************************************************************************/
-
-#ifndef __X86EMU_PRIM_ASM_H
-#define __X86EMU_PRIM_ASM_H
-
-#ifdef  __WATCOMC__
-
-#ifndef VALIDATE
-#define __HAVE_INLINE_ASSEMBLER__
-#endif
-
-u32 get_flags_asm(void);
-#pragma aux get_flags_asm =         \
-    "pushf"                         \
-    "pop    eax"                    \
-    value [eax]                     \
-    modify exact [eax];
-
-u16 aaa_word_asm(u32 * flags, u16 d);
-#pragma aux aaa_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "aaa"                           \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u16 aas_word_asm(u32 * flags, u16 d);
-#pragma aux aas_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "aas"                           \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u16 aad_word_asm(u32 * flags, u16 d);
-#pragma aux aad_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "aad"                           \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u16 aam_word_asm(u32 * flags, u8 d);
-#pragma aux aam_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "aam"                           \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u8 adc_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux adc_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "adc    al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 adc_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux adc_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "adc    ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 adc_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux adc_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "adc    eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-u8 add_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux add_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "add    al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 add_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux add_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "add    ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 add_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux add_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "add    eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-u8 and_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux and_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "and    al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 and_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux and_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "and    ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 and_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux and_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "and    eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-u8 cmp_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux cmp_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "cmp    al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 cmp_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux cmp_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "cmp    ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 cmp_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux cmp_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "cmp    eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-u8 daa_byte_asm(u32 * flags, u8 d);
-#pragma aux daa_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "daa"                           \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al]                 \
-    value [al]                      \
-    modify exact [al];
-
-u8 das_byte_asm(u32 * flags, u8 d);
-#pragma aux das_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "das"                           \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al]                 \
-    value [al]                      \
-    modify exact [al];
-
-u8 dec_byte_asm(u32 * flags, u8 d);
-#pragma aux dec_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "dec    al"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al]                 \
-    value [al]                      \
-    modify exact [al];
-
-u16 dec_word_asm(u32 * flags, u16 d);
-#pragma aux dec_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "dec    ax"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u32 dec_long_asm(u32 * flags, u32 d);
-#pragma aux dec_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "dec    eax"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax]                \
-    value [eax]                     \
-    modify exact [eax];
-
-u8 inc_byte_asm(u32 * flags, u8 d);
-#pragma aux inc_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "inc    al"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al]                 \
-    value [al]                      \
-    modify exact [al];
-
-u16 inc_word_asm(u32 * flags, u16 d);
-#pragma aux inc_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "inc    ax"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u32 inc_long_asm(u32 * flags, u32 d);
-#pragma aux inc_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "inc    eax"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax]                \
-    value [eax]                     \
-    modify exact [eax];
-
-u8 or_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux or_byte_asm =           \
-    "push   [edi]"                  \
-    "popf"                          \
-    "or al,bl"                      \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 or_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux or_word_asm =           \
-    "push   [edi]"                  \
-    "popf"                          \
-    "or ax,bx"                      \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 or_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux or_long_asm =           \
-    "push   [edi]"                  \
-    "popf"                          \
-    "or eax,ebx"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-u8 neg_byte_asm(u32 * flags, u8 d);
-#pragma aux neg_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "neg    al"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al]                 \
-    value [al]                      \
-    modify exact [al];
-
-u16 neg_word_asm(u32 * flags, u16 d);
-#pragma aux neg_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "neg    ax"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u32 neg_long_asm(u32 * flags, u32 d);
-#pragma aux neg_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "neg    eax"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax]                \
-    value [eax]                     \
-    modify exact [eax];
-
-u8 not_byte_asm(u32 * flags, u8 d);
-#pragma aux not_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "not    al"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al]                 \
-    value [al]                      \
-    modify exact [al];
-
-u16 not_word_asm(u32 * flags, u16 d);
-#pragma aux not_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "not    ax"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax]                 \
-    value [ax]                      \
-    modify exact [ax];
-
-u32 not_long_asm(u32 * flags, u32 d);
-#pragma aux not_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "not    eax"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax]                \
-    value [eax]                     \
-    modify exact [eax];
-
-u8 rcl_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux rcl_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rcl    al,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [cl]            \
-    value [al]                      \
-    modify exact [al cl];
-
-u16 rcl_word_asm(u32 * flags, u16 d, u8 s);
-#pragma aux rcl_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rcl    ax,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [cl]            \
-    value [ax]                      \
-    modify exact [ax cl];
-
-u32 rcl_long_asm(u32 * flags, u32 d, u8 s);
-#pragma aux rcl_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rcl    eax,cl"                 \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [cl]           \
-    value [eax]                     \
-    modify exact [eax cl];
-
-u8 rcr_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux rcr_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rcr    al,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [cl]            \
-    value [al]                      \
-    modify exact [al cl];
-
-u16 rcr_word_asm(u32 * flags, u16 d, u8 s);
-#pragma aux rcr_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rcr    ax,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [cl]            \
-    value [ax]                      \
-    modify exact [ax cl];
-
-u32 rcr_long_asm(u32 * flags, u32 d, u8 s);
-#pragma aux rcr_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rcr    eax,cl"                 \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [cl]           \
-    value [eax]                     \
-    modify exact [eax cl];
-
-u8 rol_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux rol_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rol    al,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [cl]            \
-    value [al]                      \
-    modify exact [al cl];
-
-u16 rol_word_asm(u32 * flags, u16 d, u8 s);
-#pragma aux rol_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rol    ax,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [cl]            \
-    value [ax]                      \
-    modify exact [ax cl];
-
-u32 rol_long_asm(u32 * flags, u32 d, u8 s);
-#pragma aux rol_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "rol    eax,cl"                 \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [cl]           \
-    value [eax]                     \
-    modify exact [eax cl];
-
-u8 ror_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux ror_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "ror    al,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [cl]            \
-    value [al]                      \
-    modify exact [al cl];
-
-u16 ror_word_asm(u32 * flags, u16 d, u8 s);
-#pragma aux ror_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "ror    ax,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [cl]            \
-    value [ax]                      \
-    modify exact [ax cl];
-
-u32 ror_long_asm(u32 * flags, u32 d, u8 s);
-#pragma aux ror_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "ror    eax,cl"                 \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [cl]           \
-    value [eax]                     \
-    modify exact [eax cl];
-
-u8 shl_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux shl_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shl    al,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [cl]            \
-    value [al]                      \
-    modify exact [al cl];
-
-u16 shl_word_asm(u32 * flags, u16 d, u8 s);
-#pragma aux shl_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shl    ax,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [cl]            \
-    value [ax]                      \
-    modify exact [ax cl];
-
-u32 shl_long_asm(u32 * flags, u32 d, u8 s);
-#pragma aux shl_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shl    eax,cl"                 \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [cl]           \
-    value [eax]                     \
-    modify exact [eax cl];
-
-u8 shr_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux shr_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shr    al,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [cl]            \
-    value [al]                      \
-    modify exact [al cl];
-
-u16 shr_word_asm(u32 * flags, u16 d, u8 s);
-#pragma aux shr_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shr    ax,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [cl]            \
-    value [ax]                      \
-    modify exact [ax cl];
-
-u32 shr_long_asm(u32 * flags, u32 d, u8 s);
-#pragma aux shr_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shr    eax,cl"                 \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [cl]           \
-    value [eax]                     \
-    modify exact [eax cl];
-
-u8 sar_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux sar_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sar    al,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [cl]            \
-    value [al]                      \
-    modify exact [al cl];
-
-u16 sar_word_asm(u32 * flags, u16 d, u8 s);
-#pragma aux sar_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sar    ax,cl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [cl]            \
-    value [ax]                      \
-    modify exact [ax cl];
-
-u32 sar_long_asm(u32 * flags, u32 d, u8 s);
-#pragma aux sar_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sar    eax,cl"                 \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [cl]           \
-    value [eax]                     \
-    modify exact [eax cl];
-
-u16 shld_word_asm(u32 * flags, u16 d, u16 fill, u8 s);
-#pragma aux shld_word_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shld   ax,dx,cl"               \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [dx] [cl]       \
-    value [ax]                      \
-    modify exact [ax dx cl];
-
-u32 shld_long_asm(u32 * flags, u32 d, u32 fill, u8 s);
-#pragma aux shld_long_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shld   eax,edx,cl"             \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [edx] [cl]     \
-    value [eax]                     \
-    modify exact [eax edx cl];
-
-u16 shrd_word_asm(u32 * flags, u16 d, u16 fill, u8 s);
-#pragma aux shrd_word_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shrd   ax,dx,cl"               \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [dx] [cl]       \
-    value [ax]                      \
-    modify exact [ax dx cl];
-
-u32 shrd_long_asm(u32 * flags, u32 d, u32 fill, u8 s);
-#pragma aux shrd_long_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "shrd   eax,edx,cl"             \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [edx] [cl]     \
-    value [eax]                     \
-    modify exact [eax edx cl];
-
-u8 sbb_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux sbb_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sbb    al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 sbb_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux sbb_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sbb    ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 sbb_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux sbb_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sbb    eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-u8 sub_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux sub_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sub    al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 sub_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux sub_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sub    ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 sub_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux sub_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "sub    eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-void test_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux test_byte_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "test   al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    modify exact [al bl];
-
-void test_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux test_word_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "test   ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    modify exact [ax bx];
-
-void test_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux test_long_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "test   eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    modify exact [eax ebx];
-
-u8 xor_byte_asm(u32 * flags, u8 d, u8 s);
-#pragma aux xor_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "xor    al,bl"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [al] [bl]            \
-    value [al]                      \
-    modify exact [al bl];
-
-u16 xor_word_asm(u32 * flags, u16 d, u16 s);
-#pragma aux xor_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "xor    ax,bx"                  \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [ax] [bx]            \
-    value [ax]                      \
-    modify exact [ax bx];
-
-u32 xor_long_asm(u32 * flags, u32 d, u32 s);
-#pragma aux xor_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "xor    eax,ebx"                \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    parm [edi] [eax] [ebx]          \
-    value [eax]                     \
-    modify exact [eax ebx];
-
-void imul_byte_asm(u32 * flags, u16 * ax, u8 d, u8 s);
-#pragma aux imul_byte_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "imul   bl"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],ax"               \
-    parm [edi] [esi] [al] [bl]      \
-    modify exact [esi ax bl];
-
-void imul_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 d, u16 s);
-#pragma aux imul_word_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "imul   bx"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],ax"               \
-    "mov    [ecx],dx"               \
-    parm [edi] [esi] [ecx] [ax] [bx]\
-    modify exact [esi edi ax bx dx];
-
-void imul_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 d, u32 s);
-#pragma aux imul_long_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "imul   ebx"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],eax"              \
-    "mov    [ecx],edx"              \
-    parm [edi] [esi] [ecx] [eax] [ebx] \
-    modify exact [esi edi eax ebx edx];
-
-void mul_byte_asm(u32 * flags, u16 * ax, u8 d, u8 s);
-#pragma aux mul_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "mul    bl"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],ax"               \
-    parm [edi] [esi] [al] [bl]      \
-    modify exact [esi ax bl];
-
-void mul_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 d, u16 s);
-#pragma aux mul_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "mul    bx"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],ax"               \
-    "mov    [ecx],dx"               \
-    parm [edi] [esi] [ecx] [ax] [bx]\
-    modify exact [esi edi ax bx dx];
-
-void mul_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 d, u32 s);
-#pragma aux mul_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "mul    ebx"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],eax"              \
-    "mov    [ecx],edx"              \
-    parm [edi] [esi] [ecx] [eax] [ebx] \
-    modify exact [esi edi eax ebx edx];
-
-void idiv_byte_asm(u32 * flags, u8 * al, u8 * ah, u16 d, u8 s);
-#pragma aux idiv_byte_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "idiv   bl"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],al"               \
-    "mov    [ecx],ah"               \
-    parm [edi] [esi] [ecx] [ax] [bl]\
-    modify exact [esi edi ax bl];
-
-void idiv_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 dlo, u16 dhi, u16 s);
-#pragma aux idiv_word_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "idiv   bx"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],ax"               \
-    "mov    [ecx],dx"               \
-    parm [edi] [esi] [ecx] [ax] [dx] [bx]\
-    modify exact [esi edi ax dx bx];
-
-void idiv_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 dlo, u32 dhi, u32 s);
-#pragma aux idiv_long_asm =         \
-    "push   [edi]"                  \
-    "popf"                          \
-    "idiv   ebx"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],eax"              \
-    "mov    [ecx],edx"              \
-    parm [edi] [esi] [ecx] [eax] [edx] [ebx]\
-    modify exact [esi edi eax edx ebx];
-
-void div_byte_asm(u32 * flags, u8 * al, u8 * ah, u16 d, u8 s);
-#pragma aux div_byte_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "div    bl"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],al"               \
-    "mov    [ecx],ah"               \
-    parm [edi] [esi] [ecx] [ax] [bl]\
-    modify exact [esi edi ax bl];
-
-void div_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 dlo, u16 dhi, u16 s);
-#pragma aux div_word_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "div    bx"                     \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],ax"               \
-    "mov    [ecx],dx"               \
-    parm [edi] [esi] [ecx] [ax] [dx] [bx]\
-    modify exact [esi edi ax dx bx];
-
-void div_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 dlo, u32 dhi, u32 s);
-#pragma aux div_long_asm =          \
-    "push   [edi]"                  \
-    "popf"                          \
-    "div    ebx"                    \
-    "pushf"                         \
-    "pop    [edi]"                  \
-    "mov    [esi],eax"              \
-    "mov    [ecx],edx"              \
-    parm [edi] [esi] [ecx] [eax] [edx] [ebx]\
-    modify exact [esi edi eax edx ebx];
-
-#endif
-
-#endif				/* __X86EMU_PRIM_ASM_H */
diff --git a/drivers/mmc/pxa_mmc.h b/drivers/mmc/pxa_mmc.h
deleted file mode 100644
index 6fa4268..0000000
--- a/drivers/mmc/pxa_mmc.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- *  linux/drivers/mmc/mmc_pxa.h
- *
- *  Author: Vladimir Shebordaev, Igor Oblakov
- *  Copyright:  MontaVista Software Inc.
- *
- *  $Id: mmc_pxa.h,v 0.3.1.6 2002/09/25 19:25:48 ted Exp ted $
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- */
-#ifndef __MMC_PXA_P_H__
-#define __MMC_PXA_P_H__
-
-/* PXA-250 MMC controller registers */
-
-/* MMC_STRPCL */
-#define MMC_STRPCL_STOP_CLK		(0x0001UL)
-#define MMC_STRPCL_START_CLK		(0x0002UL)
-
-/* MMC_STAT */
-#define MMC_STAT_END_CMD_RES		(0x0001UL << 13)
-#define MMC_STAT_PRG_DONE		(0x0001UL << 12)
-#define MMC_STAT_DATA_TRAN_DONE		(0x0001UL << 11)
-#define MMC_STAT_CLK_EN			(0x0001UL << 8)
-#define MMC_STAT_RECV_FIFO_FULL		(0x0001UL << 7)
-#define MMC_STAT_XMIT_FIFO_EMPTY	(0x0001UL << 6)
-#define MMC_STAT_RES_CRC_ERROR		(0x0001UL << 5)
-#define MMC_STAT_SPI_READ_ERROR_TOKEN   (0x0001UL << 4)
-#define MMC_STAT_CRC_READ_ERROR		(0x0001UL << 3)
-#define MMC_STAT_CRC_WRITE_ERROR	(0x0001UL << 2)
-#define MMC_STAT_TIME_OUT_RESPONSE	(0x0001UL << 1)
-#define MMC_STAT_READ_TIME_OUT		(0x0001UL)
-
-#define MMC_STAT_ERRORS (MMC_STAT_RES_CRC_ERROR|MMC_STAT_SPI_READ_ERROR_TOKEN\
-	|MMC_STAT_CRC_READ_ERROR|MMC_STAT_TIME_OUT_RESPONSE\
-	|MMC_STAT_READ_TIME_OUT|MMC_STAT_CRC_WRITE_ERROR)
-
-/* MMC_CLKRT */
-#define MMC_CLKRT_20MHZ			(0x0000UL)
-#define MMC_CLKRT_10MHZ			(0x0001UL)
-#define MMC_CLKRT_5MHZ			(0x0002UL)
-#define MMC_CLKRT_2_5MHZ		(0x0003UL)
-#define MMC_CLKRT_1_25MHZ		(0x0004UL)
-#define MMC_CLKRT_0_625MHZ		(0x0005UL)
-#define MMC_CLKRT_0_3125MHZ		(0x0006UL)
-
-/* MMC_SPI */
-#define MMC_SPI_DISABLE			(0x00UL)
-#define MMC_SPI_EN			(0x01UL)
-#define MMC_SPI_CS_EN			(0x01UL << 2)
-#define MMC_SPI_CS_ADDRESS		(0x01UL << 3)
-#define MMC_SPI_CRC_ON			(0x01UL << 1)
-
-/* MMC_CMDAT */
-#define MMC_CMDAT_SD_4DAT		(0x0001UL << 8)
-#define MMC_CMDAT_MMC_DMA_EN		(0x0001UL << 7)
-#define MMC_CMDAT_INIT			(0x0001UL << 6)
-#define MMC_CMDAT_BUSY			(0x0001UL << 5)
-#define MMC_CMDAT_BCR			(0x0003UL << 5)
-#define MMC_CMDAT_STREAM		(0x0001UL << 4)
-#define MMC_CMDAT_BLOCK			(0x0000UL << 4)
-#define MMC_CMDAT_WRITE			(0x0001UL << 3)
-#define MMC_CMDAT_READ			(0x0000UL << 3)
-#define MMC_CMDAT_DATA_EN		(0x0001UL << 2)
-#define MMC_CMDAT_R0			(0)
-#define MMC_CMDAT_R1			(0x0001UL)
-#define MMC_CMDAT_R2			(0x0002UL)
-#define MMC_CMDAT_R3			(0x0003UL)
-
-/* MMC_RESTO */
-#define MMC_RES_TO_MAX			(0x007fUL) /* [6:0] */
-
-/* MMC_RDTO */
-#define MMC_READ_TO_MAX			(0x0ffffUL) /* [15:0] */
-
-/* MMC_BLKLEN */
-#define MMC_BLK_LEN_MAX			(0x03ffUL) /* [9:0] */
-
-/* MMC_PRTBUF */
-#define MMC_PRTBUF_BUF_PART_FULL	(0x01UL)
-#define MMC_PRTBUF_BUF_FULL		(0x00UL    )
-
-/* MMC_I_MASK */
-#define MMC_I_MASK_TXFIFO_WR_REQ	(0x01UL << 6)
-#define MMC_I_MASK_RXFIFO_RD_REQ	(0x01UL << 5)
-#define MMC_I_MASK_CLK_IS_OFF		(0x01UL << 4)
-#define MMC_I_MASK_STOP_CMD		(0x01UL << 3)
-#define MMC_I_MASK_END_CMD_RES		(0x01UL << 2)
-#define MMC_I_MASK_PRG_DONE		(0x01UL << 1)
-#define MMC_I_MASK_DATA_TRAN_DONE       (0x01UL)
-#define MMC_I_MASK_ALL			(0x07fUL)
-
-
-/* MMC_I_REG */
-#define MMC_I_REG_TXFIFO_WR_REQ		(0x01UL << 6)
-#define MMC_I_REG_RXFIFO_RD_REQ		(0x01UL << 5)
-#define MMC_I_REG_CLK_IS_OFF		(0x01UL << 4)
-#define MMC_I_REG_STOP_CMD		(0x01UL << 3)
-#define MMC_I_REG_END_CMD_RES		(0x01UL << 2)
-#define MMC_I_REG_PRG_DONE		(0x01UL << 1)
-#define MMC_I_REG_DATA_TRAN_DONE	(0x01UL)
-#define MMC_I_REG_ALL			(0x007fUL)
-
-/* MMC_CMD */
-#define MMC_CMD_INDEX_MAX		(0x006fUL)  /* [5:0] */
-#define CMD(x)  (x)
-
-#define MMC_DEFAULT_RCA			1
-
-#define MMC_BLOCK_SIZE			512
-#define MMC_MAX_BLOCK_SIZE		512
-
-#define MMC_R1_IDLE_STATE		0x01
-#define MMC_R1_ERASE_STATE		0x02
-#define MMC_R1_ILLEGAL_CMD		0x04
-#define MMC_R1_COM_CRC_ERR		0x08
-#define MMC_R1_ERASE_SEQ_ERR		0x01
-#define MMC_R1_ADDR_ERR			0x02
-#define MMC_R1_PARAM_ERR		0x04
-
-#define MMC_R1B_WP_ERASE_SKIP		0x0002
-#define MMC_R1B_ERR			0x0004
-#define MMC_R1B_CC_ERR			0x0008
-#define MMC_R1B_CARD_ECC_ERR		0x0010
-#define MMC_R1B_WP_VIOLATION		0x0020
-#define MMC_R1B_ERASE_PARAM		0x0040
-#define MMC_R1B_OOR			0x0080
-#define MMC_R1B_IDLE_STATE		0x0100
-#define MMC_R1B_ERASE_RESET		0x0200
-#define MMC_R1B_ILLEGAL_CMD		0x0400
-#define MMC_R1B_COM_CRC_ERR		0x0800
-#define MMC_R1B_ERASE_SEQ_ERR		0x1000
-#define MMC_R1B_ADDR_ERR		0x2000
-#define MMC_R1B_PARAM_ERR		0x4000
-
-#endif /* __MMC_PXA_P_H__ */
diff --git a/drivers/net/nicext.h b/drivers/net/nicext.h
deleted file mode 100644
index ff422e7..0000000
--- a/drivers/net/nicext.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/****************************************************************************
- * Copyright(c) 2000-2001 Broadcom Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation.
- *
- * Name:        nicext.h
- *
- * Description: Broadcom Network Interface Card Extension (NICE) is an
- *              extension to Linux NET device kernel mode drivers.
- *              NICE is designed to provide additional functionalities,
- *              such as receive packet intercept. To support Broadcom NICE,
- *              the network device driver can be modified by adding an
- *              device ioctl handler and by indicating receiving packets
- *              to the NICE receive handler. Broadcom NICE will only be
- *              enabled by a NICE-aware intermediate driver, such as
- *              Broadcom Advanced Server Program Driver (BASP). When NICE
- *              is not enabled, the modified network device drivers
- *              functions exactly as other non-NICE aware drivers.
- *
- * Author:      Frankie Fan
- *
- * Created:     September 17, 2000
- *
- ****************************************************************************/
-#ifndef _nicext_h_
-#define _nicext_h_
-
-/*
- * ioctl for NICE
- */
-#define SIOCNICE	SIOCDEVPRIVATE+7
-
-/*
- * SIOCNICE:
- *
- * The following structure needs to be less than IFNAMSIZ (16 bytes) because
- * we're overloading ifreq.ifr_ifru.
- *
- * If 16 bytes is not enough, we should consider relaxing this because
- * this is no field after ifr_ifru in the ifreq structure. But we may
- * run into future compatiability problem in case of changing struct ifreq.
- */
-struct nice_req
-{
-    __u32 cmd;
-
-    union
-    {
-#ifdef __KERNEL__
-	/* cmd = NICE_CMD_SET_RX or NICE_CMD_GET_RX */
-	struct
-	{
-	    void (*nrqus1_rx)( struct sk_buff*, void* );
-	    void* nrqus1_ctx;
-	} nrqu_nrqus1;
-
-	/* cmd = NICE_CMD_QUERY_SUPPORT */
-	struct
-	{
-	    __u32 nrqus2_magic;
-	    __u32 nrqus2_support_rx:1;
-	    __u32 nrqus2_support_vlan:1;
-	    __u32 nrqus2_support_get_speed:1;
-	} nrqu_nrqus2;
-#endif
-
-	/* cmd = NICE_CMD_GET_SPEED */
-	struct
-	{
-	    unsigned int nrqus3_speed; /* 0 if link is down, */
-				       /* otherwise speed in Mbps */
-	} nrqu_nrqus3;
-
-	/* cmd = NICE_CMD_BLINK_LED */
-	struct
-	{
-	    unsigned int nrqus4_blink_time; /* blink duration in seconds */
-	} nrqu_nrqus4;
-
-    } nrq_nrqu;
-};
-
-#define nrq_rx           nrq_nrqu.nrqu_nrqus1.nrqus1_rx
-#define nrq_ctx          nrq_nrqu.nrqu_nrqus1.nrqus1_ctx
-#define nrq_support_rx   nrq_nrqu.nrqu_nrqus2.nrqus2_support_rx
-#define nrq_magic        nrq_nrqu.nrqu_nrqus2.nrqus2_magic
-#define nrq_support_vlan nrq_nrqu.nrqu_nrqus2.nrqus2_support_vlan
-#define nrq_support_get_speed nrq_nrqu.nrqu_nrqus2.nrqus2_support_get_speed
-#define nrq_speed        nrq_nrqu.nrqu_nrqus3.nrqus3_speed
-#define nrq_blink_time   nrq_nrqu.nrqu_nrqus4.nrqus4_blink_time
-
-/*
- * magic constants
- */
-#define NICE_REQUESTOR_MAGIC            0x4543494E /* NICE in ascii */
-#define NICE_DEVICE_MAGIC               0x4E494345 /* ECIN in ascii */
-
-/*
- * command field
- */
-#define NICE_CMD_QUERY_SUPPORT          0x00000001
-#define NICE_CMD_SET_RX                 0x00000002
-#define NICE_CMD_GET_RX                 0x00000003
-#define NICE_CMD_GET_SPEED              0x00000004
-#define NICE_CMD_BLINK_LED              0x00000005
-
-#endif  /* _nicext_h_ */